﻿// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
#if FEATURE_RESXREADER_LIVEDESERIALIZATION
using System.ComponentModel.Design;
#endif
#if FEATURE_SYSTEM_CONFIGURATION
using System.Configuration;
#endif
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Resources;
using System.Resources.Extensions;
using System.Reflection;
using System.Runtime.InteropServices;
#if FEATURE_APPDOMAIN
using System.Runtime.Remoting;
using System.Runtime.Serialization.Formatters.Binary;
#endif
using System.Runtime.Serialization;
#if !FEATURE_ASSEMBLYLOADCONTEXT
using System.Runtime.Versioning;
using System.Security;
#endif
using System.Text;
using System.Xml;
using System.Xml.Linq;

using Microsoft.Build.Eventing;
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using Microsoft.Build.Shared.FileSystem;
using Microsoft.Build.Tasks.ResourceHandling;
using Microsoft.Build.Utilities;
#if FEATURE_RESXREADER_LIVEDESERIALIZATION
using Microsoft.Win32;
#endif

#nullable disable

namespace Microsoft.Build.Tasks
{
    /// <summary>
    /// This class defines the "GenerateResource" MSBuild task, which enables using resource APIs
    /// to transform resource files.
    /// </summary>
    [RequiredRuntime("v2.0")]
    public sealed partial class GenerateResource : TaskExtension, IIncrementalTask
    {

        #region Fields

        // This cache helps us track the linked resource files listed inside of a resx resource file
        private ResGenDependencies _cache;

        // This is where we store the list of input files/sources
        private ITaskItem[] _sources = null;

        // Indicates whether the resource reader should use the source file's
        // directory to resolve relative file paths.
        private bool _useSourcePath = false;

        // This is needed for the actual items from the project
        private ITaskItem[] _references = null;

        // Any additional inputs to dependency checking.
        private ITaskItem[] _additionalInputs = null;

        // This is the path/name of the dependency cache file
        private ITaskItem _stateFile = null;

        // This list is all of the resource file(s) generated by the task
        private ITaskItem[] _outputResources = null;

        // List of those output resources that were not actually created, due to an error
        private ArrayList _unsuccessfullyCreatedOutFiles = new ArrayList();

        // Storage for names of *all files* written to disk.
        private ArrayList _filesWritten = new ArrayList();

        // StronglyTypedLanguage
        private string _stronglyTypedLanguage = null;

        // StronglyTypedNamespace
        private string _stronglyTypedNamespace = null;

        // StronglyTypedManifestPrefix
        private string _stronglyTypedManifestPrefix = null;

        // StronglyTypedClassName
        private string _stronglyTypedClassName = null;

        // StronglyTypedFileName
        private string _stronglyTypedFileName = null;

        // Whether the STR class should have public members; default is false
        private bool _publicClass = false;

        // Did the CodeDOM succeed when creating any Strongly Typed Resource class?
        private bool _stronglyTypedResourceSuccessfullyCreated = false;

        // When true, a separate AppDomain is always created.
        private bool _neverLockTypeAssemblies = false;

        // Newest uncorrelated input,
        // or null if not yet determined
        private string _newestUncorrelatedInput;

        // Write time of newest uncorrelated input
        // DateTime.MinValue indicates "missing" iff _newestUncorrelatedInput != null
        private DateTime _newestUncorrelatedInputWriteTime;

        // The targets may pass in the path to the SDKToolsPath. If so this should be used to generate the commandline
        // for logging purposes.  Also, when ExecuteAsTool is true, it determines where the system goes looking for resgen.exe
        private string _sdkToolsPath;

        // True if the resource generation should be sent out-of-proc to resgen.exe; false otherwise.  Defaults to true
        // because we want to execute out-of-proc when ToolsVersion is < 4.0, and the earlier targets files don't know
        // about this property.
        private bool _executeAsTool = true;

        // Path to resgen.exe
        private string _resgenPath;

#if FEATURE_APPDOMAIN
        // table of already seen types by their typename
        // note the use of the ordinal comparer that matches the case sensitive Type.GetType usage
        private Dictionary<string, Type> _typeTable = new Dictionary<string, Type>(StringComparer.Ordinal);

        /// <summary>
        /// Table of aliases for types defined in resx / resw files
        /// Ordinal comparer matches ResXResourceReader's use of a HashTable.
        /// </summary>
        private Dictionary<string, string> _aliases = new Dictionary<string, string>(StringComparer.Ordinal);
#endif // FEATURE_APPDOMAIN

#if FEATURE_RESGEN
        // Our calculation is not quite correct. Using a number substantially less than 32768 in order to
        // be sure we don't exceed it.
        private const int s_maximumCommandLength = 28000;
#endif // FEATURE_RESGEN

        // Contains the list of paths from which inputs will not be taken into account during up-to-date check.
        private ITaskItem[] _excludedInputPaths;

#if FEATURE_APPDOMAIN
        /// <summary>
        /// The task items that we remoted across the appdomain boundary
        /// we use this list to disconnect the task items once we're done.
        /// </summary>
        private List<ITaskItem> _remotedTaskItems;
#endif

        /// <summary>
        /// Satellite input assemblies.
        /// </summary>
        private List<ITaskItem> _satelliteInputs;

        #endregion  // fields

        #region Properties

        /// <summary>
        /// The names of the items to be converted. The extension must be one of the
        /// following: .txt, .resx or .resources.
        /// </summary>
        [Required]
        [Output]
        public ITaskItem[] Sources
        {
            set { _sources = value; }
            get { return _sources; }
        }

        /// <summary>
        /// Indicates whether the resource reader should use the source file's directory to
        /// resolve relative file paths.
        /// </summary>
        public bool UseSourcePath
        {
            set { _useSourcePath = value; }
            get { return _useSourcePath; }
        }

        /// <summary>
        /// Resolves types in ResX files (XML resources) for Strongly Typed Resources
        /// </summary>
        public ITaskItem[] References
        {
            set { _references = value; }
            get { return _references; }
        }

        /// <summary>
        /// Indicates whether resources should be passed through in their current serialization
        /// format. .NET Core-targeted assemblies should use this; it's the only way to support
        /// non-string resources with MSBuild running on .NET Core.
        /// </summary>
        public bool UsePreserializedResources { get; set; } = false;

        /// <summary>
        /// Additional inputs to the dependency checking done by this task. For example,
        /// the project and targets files typically should be inputs, so that if they are updated,
        /// all resources are regenerated.
        /// </summary>
        public ITaskItem[] AdditionalInputs
        {
            set { _additionalInputs = value; }
            get { return _additionalInputs; }
        }

        /// <summary>
        /// This is the path/name of the file containing the dependency cache
        /// </summary>
        public ITaskItem StateFile
        {
            set { _stateFile = value; }
            get { return _stateFile; }
        }

        /// <summary>
        /// The name(s) of the resource file to create. If the user does not specify this
        /// attribute, the task will append a .resources extension to each input filename
        /// argument and write the file to the directory that contains the input file.
        /// Includes any output files that were already up to date, but not any output files
        /// that failed to be written due to an error.
        /// </summary>
        [Output]
        public ITaskItem[] OutputResources
        {
            set { _outputResources = value; }
            get { return _outputResources; }
        }

        /// <summary>
        /// Storage for names of *all files* written to disk.  This is part of the implementation
        /// for Clean, and contains the OutputResources items and the StateFile item.
        /// Includes any output files that were already up to date, but not any output files
        /// that failed to be written due to an error.
        /// </summary>
        [Output]
        public ITaskItem[] FilesWritten
        {
            get
            {
                return (ITaskItem[])_filesWritten.ToArray(typeof(ITaskItem));
            }
        }

        /// <summary>
        /// Gets or sets the language to use when generating the class source for the strongly typed resource.
        /// This parameter must match exactly one of the languages used by the CodeDomProvider.
        /// </summary>
        public string StronglyTypedLanguage
        {
            set
            {
                // Since this string is passed directly into the framework, we don't want to
                // try to validate it -- that might prevent future expansion of supported languages.
                _stronglyTypedLanguage = value;
            }

            get
            {
                return _stronglyTypedLanguage;
            }
        }

        // Indicates whether any BinaryFormatter use should lead to a warning.
        public bool WarnOnBinaryFormatterUse
        {
            get; set;
        }

        /// <summary>
        /// Specifies the namespace to use for the generated class source for the
        /// strongly typed resource. If left blank, no namespace is used.
        /// </summary>
        public string StronglyTypedNamespace
        {
            set { _stronglyTypedNamespace = value; }
            get { return _stronglyTypedNamespace; }
        }

        /// <summary>
        /// Specifies the resource namespace or manifest prefix to use in the generated
        /// class source for the strongly typed resource.
        /// </summary>
        public string StronglyTypedManifestPrefix
        {
            set { _stronglyTypedManifestPrefix = value; }
            get { return _stronglyTypedManifestPrefix; }
        }

        /// <summary>
        /// Specifies the class name for the strongly typed resource class.  If left blank, the base
        /// name of the resource file is used.
        /// </summary>
        [Output]
        public string StronglyTypedClassName
        {
            set { _stronglyTypedClassName = value; }
            get { return _stronglyTypedClassName; }
        }

        /// <summary>
        /// Specifies the filename for the source file.  If left blank, the name of the class is
        /// used as the base filename, with the extension dependent on the language.
        /// </summary>
        [Output]
        public string StronglyTypedFileName
        {
            set { _stronglyTypedFileName = value; }
            get { return _stronglyTypedFileName; }
        }

        /// <summary>
        /// Specifies whether the strongly typed class should be created public (with public methods)
        /// instead of the default internal. Analogous to resgen.exe's /publicClass switch.
        /// </summary>
        public bool PublicClass
        {
            set { _publicClass = value; }
            get { return _publicClass; }
        }

        /// <summary>
        /// Whether this rule is generating .resources files or extracting .ResW files from assemblies.
        /// Requires some additional input filtering.
        /// </summary>
        public bool ExtractResWFiles
        {
            get;
            set;
        }

        /// <summary>
        /// (default = false)
        /// When true, a new AppDomain is always created to evaluate the .resx files.
        /// When false, a new AppDomain is created only when it looks like a user's
        ///  assembly is referenced by the .resx.
        /// </summary>
        public bool NeverLockTypeAssemblies
        {
            set { _neverLockTypeAssemblies = value; }
            get { return _neverLockTypeAssemblies; }
        }

        /// <summary>
        /// Even though the generate resource task will do the processing in process, a logging message is still generated. This logging message
        /// will include the path to the windows SDK. Since the targets now will pass in the Windows SDK path we should use this for logging.
        /// </summary>
        public string SdkToolsPath
        {
            get { return _sdkToolsPath; }
            set { _sdkToolsPath = value; }
        }

        /// <summary>
        /// Property to allow multitargeting of ResolveComReferences:  If true, tlbimp.exe and
        /// aximp.exe from the appropriate target framework will be run out-of-proc to generate
        /// the necessary wrapper assemblies.
        /// </summary>
        public bool ExecuteAsTool
        {
            set { _executeAsTool = value; }
            get { return _executeAsTool; }
        }

        /// <summary>
        /// Array of equals-separated pairs of environment
        /// variables that should be passed to the spawned resgen.exe,
        /// in addition to (or selectively overriding) the regular environment block.
        /// These aren't currently used when resgen is run in-process.
        /// </summary>
        public string[] EnvironmentVariables
        {
            get;
            set;
        }

        /// <summary>
        /// That set of paths from which tracked inputs will be ignored during
        /// Up to date checking
        /// </summary>
        public ITaskItem[] ExcludedInputPaths
        {
            get { return _excludedInputPaths; }
            set { _excludedInputPaths = value; }
        }

        /// <summary>
        /// Property used to set whether tracked incremental build will be used. If true,
        /// incremental build is turned on; otherwise, a rebuild will be forced.
        /// </summary>
        public bool MinimalRebuildFromTracking
        {
            get
            {
                // not using tracking anymore
                return false;
            }

            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// True if we should be tracking file access patterns - necessary for incremental
        /// build support.
        /// </summary>
        public bool TrackFileAccess
        {
            get
            {
                // not using tracking anymore
                return false;
            }
            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// Names of the read tracking logs.
        /// </summary>
        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "TLog", Justification = "Has now shipped as public API; plus it's unclear whether 'Tlog' or 'TLog' is the preferred casing")]
        public ITaskItem[] TLogReadFiles
        {
            get
            {
                return Array.Empty<ITaskItem>();
            }
        }

        /// <summary>
        /// Names of the write tracking logs.
        /// </summary>
        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "TLog", Justification = "Has now shipped as public API; plus it's unclear whether 'Tlog' or 'TLog' is the preferred casing")]
        public ITaskItem[] TLogWriteFiles
        {
            get
            {
                return Array.Empty<ITaskItem>();
            }
        }

        /// <summary>
        /// Intermediate directory into which the tracking logs from running this task will be placed.
        /// </summary>
        public string TrackerLogDirectory
        {
            get
            {
                return String.Empty;
            }
            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// Microsoft.Build.Utilities.ExecutableType of ResGen.exe.  Used to determine whether or not
        /// Tracker.exe needs to be used to spawn ResGen.exe.  If empty, uses a heuristic to determine
        /// a default architecture.
        /// </summary>
        public string ToolArchitecture
        {
            get
            {
                return String.Empty;
            }

            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// Path to the appropriate .NET Framework location that contains FileTracker.dll.  If set, the user
        /// takes responsibility for making sure that the bitness of the FileTracker.dll that they pass matches
        /// the bitness of the ResGen.exe that they intend to use. If not set, the task decides the appropriate
        /// location based on the current .NET Framework version.
        /// </summary>
        /// <comments>
        /// Should only need to be used in partial or full checked in toolset scenarios.
        /// </comments>
        public string TrackerFrameworkPath
        {
            get
            {
                return String.Empty;
            }

            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// Path to the appropriate Windows SDK location that contains Tracker.exe.  If set, the user takes
        /// responsibility for making sure that the bitness of the Tracker.exe that they pass matches the
        /// bitness of the ResGen.exe that they intend to use. If not set, the task decides the appropriate
        /// location based on the current Windows SDK.
        /// </summary>
        /// <comments>
        /// Should only need to be used in partial or full checked in toolset scenarios.
        /// </comments>
        public string TrackerSdkPath
        {
            get
            {
                return String.Empty;
            }

            set
            {
                // do nothing
            }
        }

        /// <summary>
        /// Where to extract ResW files.  (Could be the intermediate directory.)
        /// </summary>
        public string OutputDirectory
        {
            get;
            set;
        }

        #endregion // properties

        /// <summary>
        /// Simple public constructor.
        /// </summary>
        public GenerateResource()
        {
            // do nothing
        }

        public bool FailIfNotIncremental { get; set; }

        /// <summary>
        /// Logs a Resgen.exe command line that indicates what parameters were
        /// passed to this task. Since this task is replacing Resgen, and we used
        /// to log the Resgen.exe command line, we need to continue logging an
        /// equivalent command line.
        /// </summary>
        /// <param name="inputFiles"></param>
        /// <param name="outputFiles"></param>
        private void LogResgenCommandLine(List<ITaskItem> inputFiles, List<ITaskItem> outputFiles)
        {
            CommandLineBuilderExtension commandLineBuilder = new CommandLineBuilderExtension();

            // start the command line with the path to Resgen.exe
            commandLineBuilder.AppendFileNameIfNotNull(Path.Combine(_resgenPath, "resgen.exe"));

            GenerateResGenCommandLineWithoutResources(commandLineBuilder);

            if (StronglyTypedLanguage == null)
            {
                // append the resources to compile
                for (int i = 0; i < inputFiles.Count; ++i)
                {
                    if (!ExtractResWFiles)
                    {
                        commandLineBuilder.AppendFileNamesIfNotNull(
                            [inputFiles[i].ItemSpec, outputFiles[i].ItemSpec],
                            ",");
                    }
                    else
                    {
                        commandLineBuilder.AppendFileNameIfNotNull(inputFiles[i].ItemSpec);
                    }
                }
            }
            else
            {
                // append the resource to compile
                commandLineBuilder.AppendFileNamesIfNotNull(inputFiles.ToArray(), " ");
                commandLineBuilder.AppendFileNamesIfNotNull(outputFiles.ToArray(), " ");

                // append the strongly-typed resource details
                commandLineBuilder.AppendSwitchIfNotNull(
                    "/str:",
                    [StronglyTypedLanguage, StronglyTypedNamespace, StronglyTypedClassName, StronglyTypedFileName],
                    ",");
            }

            Log.LogCommandLine(MessageImportance.Low, commandLineBuilder.ToString());
        }

        /// <summary>
        /// Generate the parts of the resgen command line that are don't involve resgen.exe itself or the
        /// resources to be generated.
        /// </summary>
        /// <comments>
        /// Expects resGenCommand to be non-null -- otherwise, it doesn't get passed back to the caller, so it's
        /// useless anyway.
        /// </comments>
        /// <param name="resGenCommand"></param>
        private void GenerateResGenCommandLineWithoutResources(CommandLineBuilderExtension resGenCommand)
        {
            // Throw an internal error, since this method should only ever get called by other aspects of this task, not
            // anything that the user touches.
            ErrorUtilities.VerifyThrowInternalNull(resGenCommand);

            // append the /useSourcePath flag if requested.
            if (UseSourcePath)
            {
                resGenCommand.AppendSwitch("/useSourcePath");
            }

            // append the /publicClass flag if requested
            if (PublicClass)
            {
                resGenCommand.AppendSwitch("/publicClass");
            }

            // append the references, if any
            if (References != null)
            {
                foreach (ITaskItem reference in References)
                {
                    resGenCommand.AppendSwitchIfNotNull("/r:", reference);
                }
            }

            // append /compile switch if not creating strongly typed class
            if (String.IsNullOrEmpty(StronglyTypedLanguage))
            {
                resGenCommand.AppendSwitch("/compile");
            }
        }

        /// <summary>
        /// This is the main entry point for the GenerateResource task.
        /// </summary>
        /// <returns>true, if task executes successfully</returns>
        public override bool Execute()
        {
            bool outOfProcExecutionSucceeded = true;
            MSBuildEventSource.Log.GenerateResourceOverallStart();
            {
                // If we're extracting ResW files from assemblies (instead of building resources),
                // our Sources can contain PDB's, pictures, and other non-DLL's.  Prune that list.
                // .NET Framework assemblies are not included.  However, other Microsoft ones
                // such as MSTestFramework may be included (resolved from GetSDKReferenceFiles).
                if (ExtractResWFiles && Sources != null)
                {
                    _satelliteInputs = new List<ITaskItem>();

                    List<ITaskItem> newSources = new List<ITaskItem>();
                    foreach (ITaskItem item in Sources)
                    {
                        if (item.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
                        {
                            if (item.ItemSpec.EndsWith(".resources.dll", StringComparison.OrdinalIgnoreCase))
                            {
                                _satelliteInputs.Add(item);
                            }
                            else
                            {
                                newSources.Add(item);
                            }
                        }
                    }
                    Sources = newSources.ToArray();
                }

                // If there are no sources to process, just return (with success) and report the condition.
                if ((Sources == null) || (Sources.Length == 0))
                {
                    Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.NoSources");
                    // Indicate we generated nothing
                    OutputResources = null;
                    return true;
                }

                if (!ValidateParameters())
                {
                    // Indicate we generated nothing
                    OutputResources = null;
                    return false;
                }

                // In the case that OutputResources wasn't set, build up the outputs by transforming the Sources
                // However if we are extracting ResW files, we cannot easily tell which files we'll produce up front,
                // without loading each assembly.
                if (!ExtractResWFiles && !CreateOutputResourcesNames())
                {
                    // Indicate we generated nothing
                    OutputResources = null;
                    return false;
                }

                List<ITaskItem> inputsToProcess;
                List<ITaskItem> outputsToProcess;
                List<ITaskItem> cachedOutputFiles;  // For incremental builds, this is the set of already-existing, up to date files.

                GetResourcesToProcess(out inputsToProcess, out outputsToProcess, out cachedOutputFiles);

                if (inputsToProcess.Count == 0)
                {
                    if (!Log.HasLoggedErrors)
                    {
                        if (cachedOutputFiles.Count > 0)
                        {
                            OutputResources = cachedOutputFiles.ToArray();
                        }

                        Log.LogMessageFromResources("GenerateResource.NothingOutOfDate");
                    }
                    else
                    {
                        // No valid sources found--failures should have been logged in GetResourcesToProcess
                        return false;
                    }
                }
                else if (FailIfNotIncremental)
                {
                    int maxCount = Math.Min(inputsToProcess.Count, outputsToProcess.Count);
                    maxCount = Math.Min(maxCount, 5);  // Limit to just 5

                    for (int index = 0; index < maxCount; index++)
                    {
                        Log.LogErrorFromResources("GenerateResource.ProcessingFile", inputsToProcess[index], outputsToProcess[index]);
                    }

                    return false;
                }
                else
                {
                    if (!ComputePathToResGen())
                    {
                        // unable to compute the path to resgen.exe and that is necessary to
                        // continue forward, so return now.
                        return false;
                    }

                    // Check for the mark of the web on all possibly-exploitable files
                    // to be processed.
                    bool dangerousResourceFound = false;

                    foreach (ITaskItem source in _sources)
                    {
                        if (IsDangerous(source.ItemSpec))
                        {
                            Log.LogErrorWithCodeFromResources("GenerateResource.MOTW", source.ItemSpec);
                            dangerousResourceFound = true;
                        }
                    }

                    if (dangerousResourceFound)
                    {
                        // Do no further processing
                        return false;
                    }

                    if (ExecuteAsTool)
                    {
                        outOfProcExecutionSucceeded = GenerateResourcesUsingResGen(inputsToProcess, outputsToProcess);
                    }
                    else // Execute in-proc (or in a separate appdomain if necessary)
                    {
                        // Log equivalent command line as this is a convenient way to log all the references, etc
                        // even though we're not actually running resgen.exe
                        LogResgenCommandLine(inputsToProcess, outputsToProcess);

#if FEATURE_APPDOMAIN
                        // Figure out whether a separate AppDomain is required because an assembly would be locked.
                        bool needSeparateAppDomain = NeedSeparateAppDomain();

                        AppDomain appDomain = null;
#endif
                        ProcessResourceFiles process = null;

                        try
                        {
#if FEATURE_APPDOMAIN
                            if (needSeparateAppDomain)
                            {
                                // we're going to be remoting across the appdomain boundary, so
                                // create the list that we'll use to disconnect the taskitems once we're done
                                _remotedTaskItems = new List<ITaskItem>();

                                appDomain = AppDomain.CreateDomain(
                                    "generateResourceAppDomain",
                                    null,
                                    AppDomain.CurrentDomain.SetupInformation);

                                object obj = appDomain.CreateInstanceFromAndUnwrap(
                                       typeof(ProcessResourceFiles).Module.FullyQualifiedName,
                                       typeof(ProcessResourceFiles).FullName);

                                Type processType = obj.GetType();
                                ErrorUtilities.VerifyThrow(processType == typeof(ProcessResourceFiles), "Somehow got a wrong and possibly incompatible type for ProcessResourceFiles.");

                                process = (ProcessResourceFiles)obj;

                                RecordItemsForDisconnectIfNecessary(_references);
                                RecordItemsForDisconnectIfNecessary(inputsToProcess);
                                RecordItemsForDisconnectIfNecessary(outputsToProcess);
                            }
                            else
#endif
                            {
                                process = new ProcessResourceFiles();
                            }

                            process.Run(Log,
                                        _references,
                                        inputsToProcess,
                                        _satelliteInputs,
                                        outputsToProcess,
                                        UseSourcePath,
                                        UsePreserializedResources,
                                        StronglyTypedLanguage,
                                        _stronglyTypedNamespace,
                                        _stronglyTypedManifestPrefix,
                                        StronglyTypedFileName,
                                        StronglyTypedClassName,
                                        PublicClass,
                                        ExtractResWFiles,
                                        OutputDirectory,
                                        WarnOnBinaryFormatterUse);

                            this.StronglyTypedClassName = process.StronglyTypedClassName; // in case a default was chosen
                            this.StronglyTypedFileName = process.StronglyTypedFilename;   // in case a default was chosen
                            _stronglyTypedResourceSuccessfullyCreated = process.StronglyTypedResourceSuccessfullyCreated;
                            if (process.UnsuccessfullyCreatedOutFiles != null)
                            {
                                foreach (string item in process.UnsuccessfullyCreatedOutFiles)
                                {
                                    _unsuccessfullyCreatedOutFiles.Add(item);
                                }
                            }

                            if (ExtractResWFiles)
                            {
                                ITaskItem[] outputResources = process.ExtractedResWFiles.ToArray();
#if FEATURE_APPDOMAIN
                                if (needSeparateAppDomain)
                                {
                                    // Ensure we can unload the other AppDomain, yet still use the
                                    // ITaskItems we got back.  Clone them.
                                    outputResources = CloneValuesInThisAppDomain(outputResources);
                                }
#endif

                                if (cachedOutputFiles.Count > 0)
                                {
                                    OutputResources = new ITaskItem[outputResources.Length + cachedOutputFiles.Count];
                                    outputResources.CopyTo(OutputResources, 0);
                                    cachedOutputFiles.CopyTo(OutputResources, outputResources.Length);
                                }
                                else
                                {
                                    OutputResources = outputResources;
                                }

                                // Get portable library cache info (and if needed, marshal it to this AD).
                                List<ResGenDependencies.PortableLibraryFile> portableLibraryCacheInfo = process.PortableLibraryCacheInfo;
                                for (int i = 0; i < portableLibraryCacheInfo.Count; i++)
                                {
                                    _cache.UpdatePortableLibrary(portableLibraryCacheInfo[i]);
                                }
                            }

                            process = null;
                        }
                        finally
                        {
#if FEATURE_APPDOMAIN
                            if (needSeparateAppDomain && appDomain != null)
                            {
                                Log.MarkAsInactive();

                                AppDomain.Unload(appDomain);
                                process = null;
                                appDomain = null;

                                // if we've been asked to remote these items then
                                // we need to disconnect them from .NET Remoting now we're all done with them
                                if (_remotedTaskItems != null)
                                {
                                    foreach (ITaskItem item in _remotedTaskItems)
                                    {
                                        if (item is MarshalByRefObject marshalByRefObject)
                                        {
                                            // Tell remoting to forget connections to the taskitem
                                            RemotingServices.Disconnect(marshalByRefObject);
                                        }
                                    }
                                }

                                _remotedTaskItems = null;
                            }
#endif
                        }
                    }
                }

                // And now we serialize the cache to save our resgen linked file resolution for later use.
                WriteStateFile();

                RemoveUnsuccessfullyCreatedResourcesFromOutputResources();

                RecordFilesWritten();
            }

            MSBuildEventSource.Log.GenerateResourceOverallStop();

            return !Log.HasLoggedErrors && outOfProcExecutionSucceeded;
        }

#if FEATURE_RESXREADER_LIVEDESERIALIZATION
        private static readonly bool AllowMOTW = !NativeMethodsShared.IsWindows || (Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\SDK", "AllowProcessOfUntrustedResourceFiles", null) is string allowUntrustedFiles && allowUntrustedFiles.Equals("true", StringComparison.OrdinalIgnoreCase));

        private const string CLSID_InternetSecurityManager = "7b8a2d94-0ac9-11d1-896c-00c04fb6bfc4";
        private const uint ZoneInternet = 3;
        private static IInternetSecurityManager internetSecurityManager = null;
#endif

        // Resources can have arbitrarily serialized objects in them which can execute arbitrary code
        // so check to see if we should trust them before analyzing them
        private bool IsDangerous(String filename)
        {
#if !FEATURE_RESXREADER_LIVEDESERIALIZATION
            return false;
        }
#else
            // If they are opted out, there's no work to do
            if (AllowMOTW)
            {
                return false;
            }

            // First check the zone, if they are not an untrusted zone, they aren't dangerous
            if (internetSecurityManager == null)
            {
                Type iismType = Type.GetTypeFromCLSID(new Guid(CLSID_InternetSecurityManager));
                internetSecurityManager = (IInternetSecurityManager)Activator.CreateInstance(iismType);
            }

            int zone;
            internetSecurityManager.MapUrlToZone(Path.GetFullPath(filename), out zone, 0);
            if (zone < ZoneInternet)
            {
                return false;
            }

            // By default all file types that get here are considered dangerous
            bool dangerous = true;

            string extension = Path.GetExtension(filename);
            if (String.Equals(extension, ".resx", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(extension, ".resw", StringComparison.OrdinalIgnoreCase))
            {
                // XML files are only dangerous if there are unrecognized objects in them
                dangerous = false;

                using FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
                using XmlTextReader reader = new XmlTextReader(stream);
                reader.DtdProcessing = DtdProcessing.Ignore;
                reader.XmlResolver = null;
                try
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            string s = reader.LocalName;

                            // We only want to parse data nodes,
                            // the mimetype attribute gives the serializer
                            // that's requested.
                            if (reader.LocalName.Equals("data"))
                            {
                                if (reader["mimetype"] != null)
                                {
                                    dangerous = true;
                                }
                            }
                            else if (reader.LocalName.Equals("metadata"))
                            {
                                if (reader["mimetype"] != null)
                                {
                                    dangerous = true;
                                }
                            }
                        }
                    }
                }
                catch
                {
                    // If we hit an error while parsing assume there's a dangerous type in this file.
                    dangerous = true;
                }
                stream.Close();
            }

            return dangerous;
        }

        /// <summary>
        /// For setting OutputResources and ensuring it can be read after the second AppDomain has been unloaded.
        /// </summary>
        /// <param name="remoteValues">ITaskItems in another AppDomain</param>
        /// <returns></returns>
        private static ITaskItem[] CloneValuesInThisAppDomain(IList<ITaskItem> remoteValues)
        {
            ITaskItem[] clonedOutput = new ITaskItem[remoteValues.Count];
            for (int i = 0; i < remoteValues.Count; i++)
            {
                clonedOutput[i] = new TaskItem(remoteValues[i]);
            }

            return clonedOutput;
        }

        /// <summary>
        /// Remember this TaskItem so that we can disconnect it when this Task has finished executing
        /// Only if we're passing TaskItems to another AppDomain is this necessary. This call
        /// Will make that determination for you.
        /// </summary>
        private void RecordItemsForDisconnectIfNecessary(IEnumerable<ITaskItem> items)
        {
            if (_remotedTaskItems != null && items != null)
            {
                // remember that we need to disconnect these items
                _remotedTaskItems.AddRange(items);
            }
        }
#endif // FEATURE_APPDOMAIN

        /// <summary>
        /// Computes the path to ResGen.exe for use in logging and for passing to the
        /// nested ResGen task.
        /// </summary>
        /// <returns>True if the path is found (or it doesn't matter because we're executing in memory), false otherwise</returns>
        private bool ComputePathToResGen()
        {
#if FEATURE_RESGEN
            _resgenPath = null;

            if (String.IsNullOrEmpty(_sdkToolsPath))
            {
                // Important: the GenerateResource task is declared twice in Microsoft.Common.CurrentVersion.targets:
                // https://github.com/dotnet/msbuild/blob/369631b4b21ef485f4d6f35e16b0c839a971b0e9/src/Tasks/Microsoft.Common.CurrentVersion.targets#L3177-L3178
                // First for CLR >= 4.0, where SdkToolsPath is passed $(ResgenToolPath) which in turn is set to
                // $(TargetFrameworkSDKToolsDirectory).
                // But for CLR < 4.0 the SdkToolsPath is not passed, so we need to explicitly assume 3.5:
                var version = TargetDotNetFrameworkVersion.Version35;

                _resgenPath = ToolLocationHelper.GetPathToDotNetFrameworkSdkFile("resgen.exe", version);

                if (_resgenPath == null && ExecuteAsTool)
                {
                    Log.LogErrorWithCodeFromResources("General.PlatformSDKFileNotFound", "resgen.exe",
                        ToolLocationHelper.GetDotNetFrameworkSdkInstallKeyValue(version),
                        ToolLocationHelper.GetDotNetFrameworkSdkRootRegistryKey(version));
                }
            }
            else
            {
                _resgenPath = SdkToolsPathUtility.GeneratePathToTool(
                    SdkToolsPathUtility.FileInfoExists,
                    Microsoft.Build.Utilities.ProcessorArchitecture.CurrentProcessArchitecture,
                    SdkToolsPath,
                    "resgen.exe",
                    Log,
                    ExecuteAsTool);
            }

            if (_resgenPath == null && !ExecuteAsTool)
            {
                // if Resgen.exe is not installed, just use the filename
                _resgenPath = String.Empty;
                return true;
            }

            // We may be passing this to the ResGen task (wrapper around resgen.exe), in which case
            // we want to pass just the path -- ResGen will attach the "resgen.exe" onto the end
            // itself.
            if (_resgenPath != null)
            {
                _resgenPath = Path.GetDirectoryName(_resgenPath);
            }

            return _resgenPath != null;
#else
            _resgenPath = string.Empty;
            return true;
#endif
        }

        /// <summary>
        /// Wrapper around the call to the ResGen task that handles setting up the
        /// task to run properly.
        /// </summary>
        /// <param name="inputsToProcess">Array of names of inputs to be processed</param>
        /// <param name="outputsToProcess">Array of output names corresponding to the inputs</param>
        private bool GenerateResourcesUsingResGen(List<ITaskItem> inputsToProcess, List<ITaskItem> outputsToProcess)
        {
#if FEATURE_RESGEN
            bool resGenSucceeded = false;

            if (StronglyTypedLanguage != null)
            {
                resGenSucceeded = GenerateStronglyTypedResourceUsingResGen(inputsToProcess, outputsToProcess);
            }
            else
            {
                resGenSucceeded = TransformResourceFilesUsingResGen(inputsToProcess, outputsToProcess);
            }

            return resGenSucceeded;
#else
            Log.LogError("ResGen.exe not supported on .NET Core MSBuild");
            return false;
#endif
        }

#if FEATURE_RESGEN
        /// <summary>
        /// Given an instance of the ResGen task with everything but the strongly typed
        /// resource-related parameters filled out, execute the task and return the result
        /// </summary>
        /// <param name="inputsToProcess">Input files to give to resgen.exe.</param>
        /// <param name="outputsToProcess">Output files to give to resgen.exe.</param>
        private bool TransformResourceFilesUsingResGen(List<ITaskItem> inputsToProcess, List<ITaskItem> outputsToProcess)
        {
            ErrorUtilities.VerifyThrow(inputsToProcess.Count != 0, "There should be resource files to process");
            ErrorUtilities.VerifyThrow(inputsToProcess.Count == outputsToProcess.Count, "The number of inputs and outputs should be equal");

            bool succeeded = true;

            // We need to do a whole lot of work to make sure that we're not overrunning the command line ... UNLESS
            // we're running ResGen 4.0 or later, which supports response files.
            if (!_resgenPath.Equals(Path.GetDirectoryName(NativeMethodsShared.GetLongFilePath(ToolLocationHelper.GetPathToDotNetFrameworkSdkFile("resgen.exe", TargetDotNetFrameworkVersion.Version35))), StringComparison.OrdinalIgnoreCase))
            {
                ResGen resGen = CreateResGenTaskWithDefaultParameters();

                resGen.InputFiles = inputsToProcess.ToArray();
                resGen.OutputFiles = outputsToProcess.ToArray();

                ITaskItem[] outputFiles = resGen.OutputFiles;

                succeeded = resGen.Execute();

                if (!succeeded)
                {
                    foreach (ITaskItem outputFile in outputFiles)
                    {
                        if (!FileSystems.Default.FileExists(outputFile.ItemSpec))
                        {
                            _unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec);
                        }
                    }
                }
            }
            else
            {
                int initialResourceIndex = 0;
                bool doneProcessingResources = false;
                CommandLineBuilderExtension resourcelessCommandBuilder = new CommandLineBuilderExtension();
                string resourcelessCommand = null;

                GenerateResGenCommandLineWithoutResources(resourcelessCommandBuilder);

                if (resourcelessCommandBuilder.Length > 0)
                {
                    resourcelessCommand = resourcelessCommandBuilder.ToString();
                }

                while (!doneProcessingResources)
                {
                    int numberOfResourcesToAdd = CalculateResourceBatchSize(inputsToProcess, outputsToProcess, resourcelessCommand, initialResourceIndex);
                    ResGen resGen = CreateResGenTaskWithDefaultParameters();

                    resGen.InputFiles = inputsToProcess.GetRange(initialResourceIndex, numberOfResourcesToAdd).ToArray();
                    resGen.OutputFiles = outputsToProcess.GetRange(initialResourceIndex, numberOfResourcesToAdd).ToArray();

                    ITaskItem[] outputFiles = resGen.OutputFiles;

                    bool thisBatchSucceeded = resGen.Execute();

                    // This batch failed, so add the failing resources from this batch to the list of failures
                    if (!thisBatchSucceeded)
                    {
                        foreach (ITaskItem outputFile in outputFiles)
                        {
                            if (!FileSystems.Default.FileExists(outputFile.ItemSpec))
                            {
                                _unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec);
                            }
                        }
                    }

                    initialResourceIndex += numberOfResourcesToAdd;
                    doneProcessingResources = initialResourceIndex == inputsToProcess.Count;
                    succeeded = succeeded && thisBatchSucceeded;
                }
            }

            return succeeded;
        }

        /// <summary>
        /// Given the list of inputs and outputs, returns the number of resources (starting at the provided initial index)
        /// that can fit onto the commandline without exceeding MaximumCommandLength.
        /// </summary>
        private int CalculateResourceBatchSize(List<ITaskItem> inputsToProcess, List<ITaskItem> outputsToProcess, string resourcelessCommand, int initialResourceIndex)
        {
            CommandLineBuilderExtension currentCommand = new CommandLineBuilderExtension();

            if (!String.IsNullOrEmpty(resourcelessCommand))
            {
                currentCommand.AppendTextUnquoted(resourcelessCommand);
            }

            int i = initialResourceIndex;
            while (currentCommand.Length < s_maximumCommandLength && i < inputsToProcess.Count)
            {
                currentCommand.AppendFileNamesIfNotNull(
                        [inputsToProcess[i], outputsToProcess[i]],
                        ",");
                i++;
            }

            int numberOfResourcesToAdd;
            if (currentCommand.Length <= s_maximumCommandLength)
            {
                // We've successfully added all the rest.
                numberOfResourcesToAdd = i - initialResourceIndex;
            }
            else
            {
                // The last one added tossed us over the edge.
                numberOfResourcesToAdd = i - initialResourceIndex - 1;
            }

            return numberOfResourcesToAdd;
        }

        /// <summary>
        /// Given an instance of the ResGen task with everything but the strongly typed
        /// resource-related parameters filled out, execute the task and return the result
        /// </summary>
        /// <param name="inputsToProcess">Input files to give to resgen.exe.</param>
        /// <param name="outputsToProcess">Output files to give to resgen.exe.</param>
        private bool GenerateStronglyTypedResourceUsingResGen(List<ITaskItem> inputsToProcess, List<ITaskItem> outputsToProcess)
        {
            ErrorUtilities.VerifyThrow(inputsToProcess.Count == 1 && outputsToProcess.Count == 1, "For STR, there should only be one input and one output.");

            ResGen resGen = CreateResGenTaskWithDefaultParameters();

            resGen.InputFiles = inputsToProcess.ToArray();
            resGen.OutputFiles = outputsToProcess.ToArray();

            resGen.StronglyTypedLanguage = StronglyTypedLanguage;
            resGen.StronglyTypedNamespace = StronglyTypedNamespace;
            resGen.StronglyTypedClassName = StronglyTypedClassName;
            resGen.StronglyTypedFileName = StronglyTypedFileName;

            // Save the output file name -- ResGen will delete failing files
            ITaskItem outputFile = resGen.OutputFiles[0];

            _stronglyTypedResourceSuccessfullyCreated = resGen.Execute();

            if (!_stronglyTypedResourceSuccessfullyCreated && (resGen.OutputFiles == null || resGen.OutputFiles.Length == 0))
            {
                _unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec);
            }

            // now need to set the defaults (if defaults were chosen) so that they can be
            // consumed by outside users
            StronglyTypedClassName = resGen.StronglyTypedClassName;
            StronglyTypedFileName = resGen.StronglyTypedFileName;

            return _stronglyTypedResourceSuccessfullyCreated;
        }

        /// <summary>
        /// Factoring out the setting of the default parameters to the
        /// ResGen task.
        /// </summary>
        private ResGen CreateResGenTaskWithDefaultParameters()
        {
            ResGen resGen = new ResGen();

            resGen.BuildEngine = BuildEngine;
            resGen.SdkToolsPath = _resgenPath;
            resGen.PublicClass = PublicClass;
            resGen.References = References;
            resGen.UseSourcePath = UseSourcePath;
            resGen.EnvironmentVariables = EnvironmentVariables;

            return resGen;
        }
#endif

        /// <summary>
        /// Check for parameter errors.
        /// </summary>
        /// <returns>true if parameters are valid</returns>
        private bool ValidateParameters()
        {
            // make sure that if the output resources were set, they exactly match the number of input sources
            if ((OutputResources != null) && (OutputResources.Length != Sources.Length))
            {
                Log.LogErrorWithCodeFromResources("General.TwoVectorsMustHaveSameLength", Sources.Length, OutputResources.Length, "Sources", "OutputResources");
                return false;
            }

            // Creating an STR is triggered merely by setting the language
            if (_stronglyTypedLanguage != null)
            {
                // Like Resgen.exe, only a single Sources is allowed if you are generating STR.
                // Otherwise, each STR class overwrites the previous one. In theory we could generate separate
                // STR classes for each input, but then the class name and file name parameters would have to be vectors.
                if (Sources.Length != 1)
                {
                    Log.LogErrorWithCodeFromResources("GenerateResource.STRLanguageButNotExactlyOneSourceFile");
                    return false;
                }
            }
            else
            {
                if (StronglyTypedClassName != null || StronglyTypedNamespace != null || StronglyTypedFileName != null || StronglyTypedManifestPrefix != null)
                {
                    // We have no language to generate a STR, but nevertheless the user passed us a class,
                    // namespace, and/or filename. Let them know that they probably wanted to pass a language too.
                    Log.LogErrorWithCodeFromResources("GenerateResource.STRClassNamespaceOrFilenameWithoutLanguage");
                    return false;
                }
            }

            if (ExtractResWFiles && ExecuteAsTool)
            {
                // This combination isn't currently supported, because ResGen may produce some not-easily-predictable
                // set of ResW files and we don't have any logic to get that set of files back into GenerateResource
                // at the moment.  This could be solved fixed with some engineering effort.
                Log.LogErrorWithCodeFromResources("GenerateResource.ExecuteAsToolAndExtractResWNotSupported");
                return false;
            }

            return true;
        }

        /// <summary>
        /// Returns true if everything is up to date and we don't need to do any work.
        /// </summary>
        /// <returns></returns>
        private void GetResourcesToProcess(out List<ITaskItem> inputsToProcess, out List<ITaskItem> outputsToProcess, out List<ITaskItem> cachedOutputFiles)
        {
            // First we look to see if we have a resgen linked files cache.  If so, then we can use that
            // cache to speed up processing.
            ReadStateFile();

            bool nothingOutOfDate = true;
            inputsToProcess = new List<ITaskItem>();
            outputsToProcess = new List<ITaskItem>();
            cachedOutputFiles = new List<ITaskItem>();

            // decide what sources we need to build
            for (int i = 0; i < Sources.Length; ++i)
            {
                if (ExtractResWFiles)
                {
                    // We can't cheaply predict the output files, since that would require
                    // loading each assembly.  So don't even try guessing what they will be.
                    // However, our cache will sometimes record all the info we need (for incremental builds).
                    string sourceFileName = Sources[i].ItemSpec;
                    ResGenDependencies.PortableLibraryFile library = _cache.TryGetPortableLibraryInfo(sourceFileName);
                    if (library?.AllOutputFilesAreUpToDate() == true)
                    {
                        AppendCachedOutputTaskItems(library, cachedOutputFiles);
                    }
                    else
                    {
                        inputsToProcess.Add(Sources[i]);
                    }

                    continue;
                }

                // Attributes from input items are forwarded to output items.
                Sources[i].CopyMetadataTo(OutputResources[i]);
                Sources[i].SetMetadata("OutputResource", OutputResources[i].ItemSpec);

                if (!FileSystems.Default.FileExists(Sources[i].ItemSpec))
                {
                    // Error but continue with the files that do exist
                    Log.LogErrorWithCodeFromResources("GenerateResource.ResourceNotFound", Sources[i].ItemSpec);
                    _unsuccessfullyCreatedOutFiles.Add(OutputResources[i].ItemSpec);
                }
                else
                {
                    // check to see if the output resources file (and, if it is a .resx, any linked files)
                    // is up to date compared to the input file
                    if (ShouldRebuildResgenOutputFile(Sources[i].ItemSpec, OutputResources[i].ItemSpec))
                    {
                        nothingOutOfDate = false;
                        inputsToProcess.Add(Sources[i]);
                        outputsToProcess.Add(OutputResources[i]);
                    }
                }
            }

            // If the STR class file is out of date (for example, it's missing) we don't want to skip
            // resource generation.
            if (_stronglyTypedLanguage != null)
            {
                // We're generating a STR class file, so there must be exactly one input resource file.
                // If that resource file itself is out of date, the STR class file is going to get generated anyway.
                if (nothingOutOfDate && FileSystems.Default.FileExists(Sources[0].ItemSpec))
                {
                    GetStronglyTypedResourceToProcess(ref inputsToProcess, ref outputsToProcess);
                }
            }
        }

        /// <summary>
        /// Given a cached portable library that is up to date, create ITaskItems to represent the output of the task, as if we did real work.
        /// </summary>
        /// <param name="library">The portable library cache entry to extract output files and metadata from.</param>
        /// <param name="cachedOutputFiles">List of output files produced from the cache.</param>
        private void AppendCachedOutputTaskItems(ResGenDependencies.PortableLibraryFile library, List<ITaskItem> cachedOutputFiles)
        {
            foreach (string outputFileName in library.OutputFiles)
            {
                ITaskItem item = new TaskItem(outputFileName);
                item.SetMetadata("ResourceIndexName", library.AssemblySimpleName);
                if (library.NeutralResourceLanguage != null)
                {
                    item.SetMetadata("NeutralResourceLanguage", library.NeutralResourceLanguage);
                }

                cachedOutputFiles.Add(item);
            }
        }

        /// <summary>
        /// Checks if this list contain any duplicates.  Do this so we don't have any races where we have two
        /// threads trying to write to the same file simultaneously.
        /// </summary>
        /// <param name="originalList">A list that may have duplicates</param>
        /// <returns>Were there duplicates?</returns>
        private bool ContainsDuplicates(IList<ITaskItem> originalList)
        {
            HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (ITaskItem item in originalList)
            {
                try
                {
                    // Get the fully qualified path, to ensure two file names don't end up pointing to the same directory.
                    if (!set.Add(item.GetMetadata("FullPath")))
                    {
                        Log.LogErrorWithCodeFromResources("GenerateResource.DuplicateOutputFilenames", item.ItemSpec);
                        return true;
                    }
                }
                catch (InvalidOperationException e)
                {
                    Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message);
                    // Returning true causes us to not continue executing.
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Determines if the given output file is up to date with respect to the
        /// the given input file by comparing timestamps of the two files as well as
        /// (if the source is a .resx) the linked files inside the .resx file itself
        /// </summary>
        /// <param name="sourceFilePath"></param>
        /// <param name="outputFilePath"></param>
        /// <returns></returns>
        private bool ShouldRebuildResgenOutputFile(string sourceFilePath, string outputFilePath)
        {
            // See if any uncorrelated inputs are missing before checking source and output file timestamps.
            // Only do this if we already checked the uncorrelated inputs, since
            // typically, it's the .resx's that are out of date so we want to check those first.
            if (_newestUncorrelatedInput != null && _newestUncorrelatedInputWriteTime == DateTime.MinValue)
            {
                // An uncorrelated input is missing; need to build
                // We logged this once already, when we found it
                return true;
            }

            DateTime outputTime = NativeMethodsShared.GetLastWriteFileUtcTime(outputFilePath);

            // Quick check to see if any uncorrelated input is newer in which case we can avoid checking source file timestamp
            if (_newestUncorrelatedInput != null && _newestUncorrelatedInputWriteTime > outputTime)
            {
                // An uncorrelated input is newer, need to build
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", _newestUncorrelatedInput, outputFilePath);
                return true;
            }

            DateTime sourceTime = NativeMethodsShared.GetLastWriteFileUtcTime(sourceFilePath);

            string extension = Path.GetExtension(sourceFilePath);
            if (!String.Equals(extension, ".resx", StringComparison.OrdinalIgnoreCase) &&
                !String.Equals(extension, ".resw", StringComparison.OrdinalIgnoreCase))
            {
                // If source file is NOT a .resx, for example a .restext file,
                // timestamp checking is simple, because there's no linked files to examine, and no references.
                return NeedToRebuildSourceFile(sourceFilePath, sourceTime, outputFilePath, outputTime);
            }

            // OK, we have a .resx file

            // PERF: Regardless of whether the outputFile exists, if the source file is a .resx
            // go ahead and retrieve it from the cache. This is because we want the cache
            // to be populated so that incremental builds can be fast.
            // Note that this is a trade-off: clean builds will be slightly slower. However,
            // for clean builds we're about to read in this very same .resx file so reading
            // it now will page it in. The second read should be cheap.
            ResGenDependencies.ResXFile resxFileInfo;
            try
            {
                resxFileInfo = _cache.GetResXFileInfo(sourceFilePath, UsePreserializedResources, Log, WarnOnBinaryFormatterUse);
            }
            catch (Exception e) when (!ExceptionHandling.NotExpectedIoOrXmlException(e) || e is MSBuildResXException)
            {
                // Return true, so that resource processing will display the error
                // No point logging a duplicate error here as well
                return true;
            }

            // if the .resources file is out of date even just with respect to the .resx or
            // the additional inputs, we don't need to go to the point of checking the linked files.
            if (NeedToRebuildSourceFile(sourceFilePath, sourceTime, outputFilePath, outputTime))
            {
                // This already logged the reason
                return true;
            }

            // The .resources is up to date with respect to the .resx file -
            // we need to compare timestamps for each linked file inside
            // the .resx file itself
            if (resxFileInfo.LinkedFiles != null)
            {
                foreach (string linkedFilePath in resxFileInfo.LinkedFiles)
                {
                    DateTime linkedFileTime = NativeMethodsShared.GetLastWriteFileUtcTime(linkedFilePath);

                    if (linkedFileTime == DateTime.MinValue)
                    {
                        // Linked file is missing - force a build, so that resource generation
                        // will produce a nice error message
                        Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.LinkedInputDoesntExist", linkedFilePath);
                        return true;
                    }

                    if (linkedFileTime > outputTime)
                    {
                        // Linked file is newer, need to build
                        Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.LinkedInputNewer", linkedFilePath, outputFilePath);
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// Returns true if the output does not exist, if the provided source is newer than the output,
        /// or if any of the set of additional inputs is newer than the output.  Otherwise, returns false.
        /// </summary>
        private bool NeedToRebuildSourceFile(string sourceFilePath, DateTime sourceTime, string outputFilePath, DateTime outputTime)
        {
            if (outputTime == DateTime.MinValue)
            {
                // Output file is missing, need to build
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.OutputDoesntExist", outputFilePath);
                return true;
            }

            if (sourceTime > outputTime)
            {
                // Source file is newer, need to build
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", sourceFilePath, outputFilePath);
                return true;
            }

            UpdateNewestUncorrelatedInputWriteTime();
            if (_newestUncorrelatedInput != null && _newestUncorrelatedInputWriteTime > outputTime)
            {
                // An uncorrelated input is newer, need to build
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", _newestUncorrelatedInput, outputFilePath);
                return true;
            }

            return false;
        }

        /// <summary>
        /// Add the strongly typed resource to the set of resources to process if it is out of date.
        /// </summary>
        private void GetStronglyTypedResourceToProcess(ref List<ITaskItem> inputsToProcess, ref List<ITaskItem> outputsToProcess)
        {
            bool needToRebuildSTR = false;
            CodeDomProvider provider = null;

            // The resource file isn't out of date. So check whether the STR class file is.
            try
            {
                if (StronglyTypedFileName == null)
                {
                    if (ProcessResourceFiles.TryCreateCodeDomProvider(Log, StronglyTypedLanguage, out provider))
                    {
                        StronglyTypedFileName = ProcessResourceFiles.GenerateDefaultStronglyTypedFilename(provider, OutputResources[0].ItemSpec);
                    }
                }
            }
            catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
            {
                Log.LogErrorWithCodeFromResources("GenerateResource.CannotWriteSTRFile", StronglyTypedFileName, e.Message);
                // Now that we've logged an error, we know we're not going to do anything more, so
                // don't bother to correctly populate the inputs / outputs.
                _unsuccessfullyCreatedOutFiles.Add(OutputResources[0].ItemSpec);
                _stronglyTypedResourceSuccessfullyCreated = false;
                return;
            }
            finally
            {
                provider?.Dispose();
            }

            // Now we have the filename, check if it's up to date
            DateTime sourceTime = NativeMethodsShared.GetLastWriteFileUtcTime(Sources[0].ItemSpec);
            DateTime outputTime = NativeMethodsShared.GetLastWriteFileUtcTime(StronglyTypedFileName);

            if (sourceTime == DateTime.MinValue)
            {
                // Source file is missing - force a build, so that resource generation
                // will produce a nice error message
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputDoesntExist", Sources[0].ItemSpec);
                needToRebuildSTR = true;
            }
            else if (outputTime == DateTime.MinValue)
            {
                // Output file is missing, need to build it
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.OutputDoesntExist", StronglyTypedFileName);
                needToRebuildSTR = true;
            }
            else if (sourceTime > outputTime)
            {
                // Source file is newer, need to build
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", Sources[0].ItemSpec, StronglyTypedFileName);
                needToRebuildSTR = true;
            }

            if (needToRebuildSTR)
            {
                // We know there's only one input, just make sure it gets processed and that will cause
                // the STR class file to get updated
                if (inputsToProcess.Count == 0)
                {
                    inputsToProcess.Add(Sources[0]);
                    outputsToProcess.Add(OutputResources[0]);
                }
            }
            else
            {
                // If the STR class file is up to date and was skipped then we
                // should consider the file written and add it to FilesWritten output
                _stronglyTypedResourceSuccessfullyCreated = true;
            }
        }

        /// <summary>
        /// Returns the newest last write time among the references and additional inputs.
        /// If any do not exist, returns DateTime.MaxValue so that resource generation produces a nice error.
        /// </summary>
        private void UpdateNewestUncorrelatedInputWriteTime()
        {
            if (_newestUncorrelatedInput != null)
            {
                // We already did this
                return;
            }

            // Check the timestamp of each of the passed-in references to find the newest;
            // and then the additional inputs
            var inputs = (this.References ?? []).Concat(this.AdditionalInputs ?? []);

            foreach (ITaskItem input in inputs)
            {
                DateTime time = NativeMethodsShared.GetLastWriteFileUtcTime(input.ItemSpec);

                if (time == DateTime.MinValue)
                {
                    // File does not exist: force a build to produce an error message
                    _newestUncorrelatedInput = input.ItemSpec;
                    _newestUncorrelatedInputWriteTime = time;
                    // Log it here so it's logged only once for all inputs
                    Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputDoesntExist", _newestUncorrelatedInput);
                    return;
                }

                if (time > _newestUncorrelatedInputWriteTime)
                {
                    _newestUncorrelatedInput = input.ItemSpec;
                    _newestUncorrelatedInputWriteTime = time;
                }
            }
        }

#if FEATURE_APPDOMAIN
        /// <summary>
        /// Make the decision about whether a separate AppDomain is needed.
        /// If this algorithm is unsure about whether a separate AppDomain is
        /// needed, it should always err on the side of returning 'true'. This
        /// is because a separate AppDomain, while slow to create, is always safe.
        /// </summary>
        /// <returns></returns>
        private bool NeedSeparateAppDomain()
        {
            if (NeverLockTypeAssemblies)
            {
                Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.SeparateAppDomainBecauseNeverLockTypeAssembliesTrue");
                return true;
            }

            foreach (ITaskItem source in _sources)
            {
                string extension = Path.GetExtension(source.ItemSpec);

                if (String.Equals(extension, ".resources.dll", StringComparison.OrdinalIgnoreCase) ||
                    String.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) ||
                    String.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }

                if (String.Equals(extension, ".resx", StringComparison.OrdinalIgnoreCase) ||
                    String.Equals(extension, ".resw", StringComparison.OrdinalIgnoreCase))
                {
                    XmlReader reader = null;
                    string name = null;

                    try
                    {
                        XmlReaderSettings readerSettings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore, CloseInput = true };

                        FileStream fs = File.OpenRead(source.ItemSpec);
                        reader = XmlReader.Create(fs, readerSettings);

                        while (reader.Read())
                        {
                            // Look for the <data> section
                            if (reader.NodeType == XmlNodeType.Element)
                            {
                                if (String.Equals(reader.Name, "data", StringComparison.OrdinalIgnoreCase))
                                {
                                    // Is there an attribute called type?
                                    string typeName = reader.GetAttribute("type");
                                    name = reader.GetAttribute("name");

                                    if (typeName != null)
                                    {
                                        Type type;

                                        // It is likely that we've seen this type before
                                        // we'll try our table of previously seen types
                                        // since it is *much* faster to do that than
                                        // call Type.GetType needlessly!
                                        if (!_typeTable.TryGetValue(typeName, out type))
                                        {
                                            string resolvedTypeName = typeName;

                                            // This type name might be an alias, so first resolve that if any.
                                            int indexOfSeperator = typeName.IndexOf(',');

                                            if (indexOfSeperator != -1)
                                            {
                                                string typeFromTypeName = typeName.Substring(0, indexOfSeperator);
                                                string maybeAliasFromTypeName = typeName.Substring(indexOfSeperator + 1);

                                                if (!String.IsNullOrWhiteSpace(maybeAliasFromTypeName))
                                                {
                                                    maybeAliasFromTypeName = maybeAliasFromTypeName.Trim();

                                                    string fullName = null;
                                                    if (_aliases.TryGetValue(maybeAliasFromTypeName, out fullName))
                                                    {
                                                        resolvedTypeName = typeFromTypeName + ", " + fullName;
                                                    }
                                                }
                                            }

                                            // Can this type be found in the GAC?
                                            type = Type.GetType(resolvedTypeName, throwOnError: false, ignoreCase: false);

                                            // Remember our resolved type
                                            _typeTable[typeName] = type;
                                        }

                                        if (type == null)
                                        {
                                            // If the type could not be found in the GAC, then we're going to need
                                            // to load the referenced assemblies (those passed in through the
                                            // "References" parameter during the building of this .RESX.  Therefore,
                                            // we should create a separate app-domain, so that those assemblies
                                            // can be unlocked when the task is finished.
                                            // The type didn't start with "System." so return true.
                                            Log.LogMessageFromResources(
                                                MessageImportance.Low,
                                                "GenerateResource.SeparateAppDomainBecauseOfType",
                                                name ?? String.Empty,
                                                typeName,
                                                source.ItemSpec,
                                                ((IXmlLineInfo)reader).LineNumber);

                                            return true;
                                        }

                                        // If there's a type, we don't need to look at any mimetype
                                        continue;
                                    }

                                    // DDB #9825.
                                    // There's no type attribute on this <data> -- if there's a MimeType, it's a serialized
                                    // object of unknown type, and we have to assume it will need a new app domain.
                                    // The possible mimetypes ResXResourceReader understands are:
                                    //
                                    // application/x-microsoft.net.object.binary.base64
                                    // application/x-microsoft.net.object.bytearray.base64
                                    // application/x-microsoft.net.object.binary.base64
                                    // application/x-microsoft.net.object.soap.base64
                                    // text/microsoft-urt/binary-serialized/base64
                                    // text/microsoft-urt/psuedoml-serialized/base64
                                    // text/microsoft-urt/soap-serialized/base64
                                    //
                                    // Of these, application/x-microsoft.net.object.bytearray.base64 usually has a type attribute
                                    // as well; ResxResourceReader will use that Type, which may not need a new app domain. So
                                    // if there's a type attribute, we don't look at mimetype.
                                    //
                                    // If there is a mimetype and no type, we can't tell the type without deserializing and loading it,
                                    // so we assume a new appdomain is needed.
                                    //
                                    // Actually, if application/x-microsoft.net.object.bytearray.base64 doesn't have a Type attribute,
                                    // ResxResourceReader assumes System.String, but for safety we don't assume that here.

                                    string mimeType = reader.GetAttribute("mimetype");

                                    if (mimeType != null)
                                    {
                                        if (NeedSeparateAppDomainBasedOnSerializedType(reader))
                                        {
                                            Log.LogMessageFromResources(
                                                MessageImportance.Low,
                                                "GenerateResource.SeparateAppDomainBecauseOfMimeType",
                                                name ?? String.Empty,
                                                mimeType,
                                                source.ItemSpec,
                                                ((IXmlLineInfo)reader).LineNumber);

                                            return true;
                                        }
                                    }
                                }
                                else if (String.Equals(reader.Name, "assembly", StringComparison.OrdinalIgnoreCase))
                                {
                                    string alias = reader.GetAttribute("alias");
                                    string fullName = reader.GetAttribute("name");

                                    if (!String.IsNullOrWhiteSpace(alias) && !String.IsNullOrWhiteSpace(fullName))
                                    {
                                        alias = alias.Trim();
                                        fullName = fullName.Trim();

                                        _aliases[alias] = fullName;
                                    }
                                }
                            }
                        }
                    }
                    catch (XmlException e)
                    {
                        Log.LogMessageFromResources(
                                        MessageImportance.Low,
                                        "GenerateResource.SeparateAppDomainBecauseOfExceptionLineNumber",
                                        source.ItemSpec,
                                        ((IXmlLineInfo)reader).LineNumber,
                                        e.Message);

                        return true;
                    }
                    catch (SerializationException e)
                    {
                        Log.LogMessageFromResources(
                                        MessageImportance.Low,
                                        "GenerateResource.SeparateAppDomainBecauseOfErrorDeserializingLineNumber",
                                        source.ItemSpec,
                                        name ?? String.Empty,
                                        ((IXmlLineInfo)reader).LineNumber,
                                        e.Message);

                        return true;
                    }
                    catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
                    {
                        // DDB#9819
                        // Customers have reported the following exceptions coming out of this method's call to GetType():
                        //      System.Runtime.InteropServices.COMException (0x8000000A): The data necessary to complete this operation is not yet available. (Exception from HRESULT: 0x8000000A)
                        //      System.NullReferenceException: Object reference not set to an instance of an object.
                        //      System.InvalidOperationException: Collection was modified; enumeration operation may not execute.
                        // We don't have reproes, but probably the right thing to do is to assume a new app domain is needed on almost any exception.
                        // Any problem loading the type will get logged later when the resource reader tries it.
                        //
                        // XmlException or an IO exception is also possible from an invalid input file.

                        // If there was any problem parsing the .resx then log a message and
                        // fall back to using a separate AppDomain.
                        Log.LogMessageFromResources(
                                        MessageImportance.Low,
                                        "GenerateResource.SeparateAppDomainBecauseOfException",
                                        source.ItemSpec,
                                        e.Message);

                        // In case we need more information from the customer (given this has been heavily reported
                        // and we don't understand it properly) let the usual debug switch dump the stack.
                        if (Environment.GetEnvironmentVariable("MSBUILDDEBUG") == "1")
                        {
                            Log.LogErrorFromException(e, /* stack */ true, /* inner exceptions */ true, null);
                        }

                        return true;
                    }
                    finally
                    {
                        reader?.Close();
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// Finds the "value" element expected to be the next element read from the supplied reader.
        /// Deserializes the data content in order to figure out whether it implies a new app domain
        /// should be used to process resources.
        /// </summary>
        private bool NeedSeparateAppDomainBasedOnSerializedType(XmlReader reader)
        {
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (!String.Equals(reader.Name, "value", StringComparison.OrdinalIgnoreCase))
                    {
                        // <data> claimed it was serialized, but didn't have a <value>;
                        // return true to err on side of caution
                        return true;
                    }

                    // Found "value" element
                    string data = reader.ReadElementContentAsString();

                    bool isSerializedObjectLoadable = DetermineWhetherSerializedObjectLoads(data);

                    // If it's not loadable, it's presumably a user type, so create a new app domain
                    return !isSerializedObjectLoadable;
                }
            }

            // We didn't find any element at all -- the .resx is malformed.
            // Return true to err on the side of caution. Error will appear later.
            return true;
        }

        /// <summary>
        /// Deserializes a base64 block from a resx in order to figure out if its type is in the GAC.
        /// Because we're not providing any assembly resolution callback, deserialization
        /// will attempt to load the object's type using fusion rules, which essentially means
        /// the GAC. So, if the object is null, it's definitely not in the GAC.
        /// </summary>
        private bool DetermineWhetherSerializedObjectLoads(string data)
        {
            byte[] serializedData = ByteArrayFromBase64WrappedString(data);

            BinaryFormatter binaryFormatter = new();

            using (MemoryStream memoryStream = new MemoryStream(serializedData))
            {
                // CodeQL [SM03722] required trust of BinaryFormatter-serialized resources documented at https://learn.microsoft.com/visualstudio/msbuild/generateresource-task
                // CodeQL [SM04191] required trust of BinaryFormatter-serialized resources documented at https://learn.microsoft.com/visualstudio/msbuild/generateresource-task
                object result = binaryFormatter.Deserialize(memoryStream);

                return result != null;
            }
        }

        /// <summary>
        /// Turns the nicely justified block of base64 found in a resx into a byte array.
        /// Copied from fx\src\winforms\managed\system\winforms\control.cs
        /// </summary>
        private static byte[] ByteArrayFromBase64WrappedString(string text)
        {
            if (text.AsSpan().IndexOfAny(' ', '\r', '\n') != -1) // Chars that should be ignored in the nicely justified block of base64
            {
                StringBuilder sb = new StringBuilder(text.Length);
                for (int i = 0; i < text.Length; i++)
                {
                    switch (text[i])
                    {
                        case ' ':
                        case '\r':
                        case '\n':
                            break;
                        default:
                            sb.Append(text[i]);
                            break;
                    }
                }
                return Convert.FromBase64String(sb.ToString());
            }
            else
            {
                return Convert.FromBase64String(text);
            }
        }
#endif

        /// <summary>
        /// Make sure that OutputResources has 1 file name for each name in Sources.
        /// </summary>
        private bool CreateOutputResourcesNames()
        {
            if (OutputResources == null)
            {
                OutputResources = new ITaskItem[Sources.Length];
                int i = 0;
                try
                {
                    for (i = 0; i < Sources.Length; ++i)
                    {
                        OutputResources[i] = new TaskItem(Path.ChangeExtension(Sources[i].ItemSpec, ".resources"));
                    }
                }
                catch (ArgumentException e)
                {
                    Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", Sources[i].ItemSpec, e.Message);
                    return false;
                }
            }

            // Now check for duplicates.
            if (ContainsDuplicates(OutputResources))
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Remove any output resources that we didn't successfully create (due to error) from the
        /// OutputResources list. Keeps the ordering of OutputResources the same.
        /// </summary>
        /// <remarks>
        /// Q: Why didn't we keep a "successfully created" list instead, like in the Copy task does, which
        /// would save us doing the removal algorithm below?
        /// A: Because we want the ordering of OutputResources to be the same as the ordering passed in.
        /// Some items (the up to date ones) would be added to the successful output list first, and the other items
        /// are added during processing, so the ordering would change. We could fix that up, but it's better to do
        /// the fix up only in the rarer error case. If there were no errors, the algorithm below skips.</remarks>
        private void RemoveUnsuccessfullyCreatedResourcesFromOutputResources()
        {
            // Normally, there aren't any unsuccessful conversions.
            if (_unsuccessfullyCreatedOutFiles == null ||
                _unsuccessfullyCreatedOutFiles.Count == 0)
            {
                return;
            }

            ErrorUtilities.VerifyThrow(OutputResources != null && OutputResources.Length != 0, "Should be at least one output resource");

            // We only get here if there was at least one resource generation error.
            ITaskItem[] temp = new ITaskItem[OutputResources.Length - _unsuccessfullyCreatedOutFiles.Count];
            int copied = 0;
            int removed = 0;
            for (int i = 0; i < Sources.Length; i++)
            {
                // Check whether this one is in the bad list.
                if (removed < _unsuccessfullyCreatedOutFiles.Count &&
                    _unsuccessfullyCreatedOutFiles.Contains(OutputResources[i].ItemSpec))
                {
                    removed++;
                    Sources[i].SetMetadata("OutputResource", String.Empty);
                }
                else
                {
                    // Copy it to the okay list.
                    temp[copied] = OutputResources[i];
                    copied++;
                }
            }
            OutputResources = temp;
        }

        /// <summary>
        /// Record the list of file that will be written to disk.
        /// </summary>
        private void RecordFilesWritten()
        {
            // Add any output resources that were successfully created,
            // or would have been if they weren't already up to date (important for Clean)
            if (this.OutputResources != null)
            {
                foreach (ITaskItem item in this.OutputResources)
                {
                    _filesWritten.Add(item);
                }
            }

            // Add any state file
            if (StateFile?.ItemSpec.Length > 0)
            {
                // It's possible the file wasn't actually written (eg the path was invalid)
                // We can't easily tell whether that happened here, and I think it's fine to add it anyway.
                _filesWritten.Add(StateFile);
            }

            // Only add the STR class file if the CodeDOM succeeded, or if it exists and is up to date.
            // Otherwise, we probably didn't write it successfully.
            if (_stronglyTypedResourceSuccessfullyCreated)
            {
                if (StronglyTypedFileName == null)
                {
                    CodeDomProvider provider = null;
                    try
                    {
                        if (ProcessResourceFiles.TryCreateCodeDomProvider(Log, StronglyTypedLanguage, out provider))
                        {
                            StronglyTypedFileName = ProcessResourceFiles.GenerateDefaultStronglyTypedFilename(
                                provider, OutputResources[0].ItemSpec);
                        }
                    }
                    finally
                    {
                        provider?.Dispose();
                    }
                }

                _filesWritten.Add(new TaskItem(this.StronglyTypedFileName));
            }
        }

        /// <summary>
        /// Read the state file if able.
        /// </summary>
        private void ReadStateFile()
        {
            // First we look to see if we have a resgen linked files cache.  If so, then we can use that
            // cache to speed up processing.  If there's a problem reading the cache file (or it
            // just doesn't exist, then this method will return a brand new cache object.

            // This method eats IO Exceptions
            _cache = ResGenDependencies.DeserializeCache(StateFile?.ItemSpec, UseSourcePath, Log);
            ErrorUtilities.VerifyThrow(_cache != null, "We did not create a cache!");
        }

        /// <summary>
        /// Write the state file if there is one to be written.
        /// </summary>
        private void WriteStateFile()
        {
            if (_cache.IsDirty)
            {
                // And now we serialize the cache to save our resgen linked file resolution for later use.
                _cache.SerializeCache(StateFile?.ItemSpec, Log);
            }
        }
    }

    /// <summary>
    /// This class handles the processing of source resource files into compiled resource files.
    /// Its designed to be called from a separate AppDomain so that any files locked by ResXResourceReader
    /// can be released.
    /// </summary>
    internal sealed class ProcessResourceFiles
#if FEATURE_APPDOMAIN
        : MarshalByRefObject
#endif
    {
        #region fields
        /// <summary>
        /// List of readers used for input.
        /// </summary>
        private List<ReaderInfo> _readers = new List<ReaderInfo>();

        /// <summary>
        /// Logger for any messages or errors
        /// </summary>
        private TaskLoggingHelper _logger = null;

        /// <summary>
        /// Language for the strongly typed resources.
        /// </summary>
        private string _stronglyTypedLanguage;

        /// <summary>
        /// Filename for the strongly typed resources.
        /// Getter provided since the processor may choose a default.
        /// </summary>
        internal string StronglyTypedFilename
        {
            get
            {
                return _stronglyTypedFilename;
            }
        }
        private string _stronglyTypedFilename;

        /// <summary>
        /// Namespace for the strongly typed resources.
        /// </summary>
        private string _stronglyTypedNamespace;

        /// <summary>
        /// ResourceNamespace for the strongly typed resources.
        /// </summary>
        private string _stronglyTypedResourcesNamespace;

        /// <summary>
        /// Class name for the strongly typed resources.
        /// Getter provided since the processor may choose a default.
        /// </summary>
        internal string StronglyTypedClassName
        {
            get
            {
                return _stronglyTypedClassName;
            }
        }
        private string _stronglyTypedClassName;

        /// <summary>
        /// Whether the fields in the STR class should be public, rather than internal
        /// </summary>
        private bool _stronglyTypedClassIsPublic;

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Class that gets called by the ResxResourceReader to resolve references
        /// to assemblies within the .RESX.
        /// </summary>
        private AssemblyNamesTypeResolutionService _typeResolver = null;

        /// <summary>
        /// Handles assembly resolution events.
        /// </summary>
        private ResolveEventHandler _eventHandler;
#endif

        /// <summary>
        /// The referenced assemblies
        /// </summary>
        private ITaskItem[] _assemblyFiles;

        /// <summary>
        /// The AssemblyNameExtensions for each of the referenced assemblies in "assemblyFiles".
        /// This is populated lazily.
        /// </summary>
        private AssemblyNameExtension[] _assemblyNames;

        /// <summary>
        /// List of input files to process.
        /// </summary>
        private List<ITaskItem> _inFiles;

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// List of satellite input files to process.
        /// </summary>
        private List<ITaskItem> _satelliteInFiles;
#endif

        /// <summary>
        /// List of output files to process.
        /// </summary>
        private List<ITaskItem> _outFiles;

        /// <summary>
        /// Whether we are extracting ResW files from an assembly, instead of creating .resources files.
        /// </summary>
        private bool _extractResWFiles;

        private bool _usePreserializedResources;

        internal List<ITaskItem> ExtractedResWFiles
        {
            get
            {
                if (_extractedResWFiles == null)
                {
                    _extractedResWFiles = new List<ITaskItem>();
                }
                return _extractedResWFiles;
            }
        }
        private List<ITaskItem> _extractedResWFiles;

        /// <summary>
        /// Record all the information about outputs here to avoid future incremental builds.
        /// </summary>
        internal List<ResGenDependencies.PortableLibraryFile> PortableLibraryCacheInfo
        {
            get { return _portableLibraryCacheInfo; }
        }
        private List<ResGenDependencies.PortableLibraryFile> _portableLibraryCacheInfo;

        /// <summary>
        /// List of output files that we failed to create due to an error.
        /// See note in RemoveUnsuccessfullyCreatedResourcesFromOutputResources()
        /// </summary>
        internal ArrayList UnsuccessfullyCreatedOutFiles
        {
            get
            {
                if (_unsuccessfullyCreatedOutFiles == null)
                {
                    _unsuccessfullyCreatedOutFiles = new ArrayList();
                }
                return _unsuccessfullyCreatedOutFiles;
            }
        }
        private ArrayList _unsuccessfullyCreatedOutFiles;

        /// <summary>
        /// Whether we successfully created the STR class
        /// </summary>
        internal bool StronglyTypedResourceSuccessfullyCreated
        {
            get
            {
                return _stronglyTypedResourceSuccessfullyCreated;
            }
        }
        private bool _stronglyTypedResourceSuccessfullyCreated = false;

        /// <summary>
        /// Indicates whether the resource reader should use the source file's
        /// directory to resolve relative file paths.
        /// </summary>
        private bool _useSourcePath = false;

        private bool _logWarningForBinaryFormatter = false;

        #endregion

        /// <summary>
        /// Process all files.
        /// </summary>
        internal void Run(
            TaskLoggingHelper log,
            ITaskItem[] assemblyFilesList,
            List<ITaskItem> inputs,
            List<ITaskItem> satelliteInputs,
            List<ITaskItem> outputs,
            bool sourcePath,
            bool usePreserializedResources,
            string language,
            string namespacename,
            string resourcesNamespace,
            string filename,
            string classname,
            bool publicClass,
            bool extractingResWFiles,
            string resWOutputDirectory,
            bool logWarningForBinaryFormatter)
        {
            _logger = log;
            _assemblyFiles = assemblyFilesList;
            _inFiles = inputs;
#if !FEATURE_ASSEMBLYLOADCONTEXT
            _satelliteInFiles = satelliteInputs;
#endif
            _outFiles = outputs;
            _useSourcePath = sourcePath;
            _stronglyTypedLanguage = language;
            _stronglyTypedNamespace = namespacename;
            _stronglyTypedResourcesNamespace = resourcesNamespace;
            _stronglyTypedFilename = filename;
            _stronglyTypedClassName = classname;
            _stronglyTypedClassIsPublic = publicClass;
            _readers = new List<ReaderInfo>();
            _extractResWFiles = extractingResWFiles;
            _portableLibraryCacheInfo = new List<ResGenDependencies.PortableLibraryFile>();
            _usePreserializedResources = usePreserializedResources;
            _logWarningForBinaryFormatter = logWarningForBinaryFormatter;

#if !FEATURE_ASSEMBLYLOADCONTEXT
            // If references were passed in, we will have to give the ResxResourceReader an object
            // by which it can resolve types that are referenced from within the .RESX.
            if ((_assemblyFiles?.Length > 0))
            {
                _typeResolver = new AssemblyNamesTypeResolutionService(_assemblyFiles);
            }
#endif

            try
            {
#if !FEATURE_ASSEMBLYLOADCONTEXT
                // Install assembly resolution event handler.
                _eventHandler = new ResolveEventHandler(ResolveAssembly);
                AppDomain.CurrentDomain.AssemblyResolve += _eventHandler;
#endif

                for (int i = 0; i < _inFiles.Count; ++i)
                {
                    string outputSpec = _extractResWFiles ? resWOutputDirectory : _outFiles[i].ItemSpec;
                    if (!ProcessFile(_inFiles[i].ItemSpec, outputSpec))
                    {
                        // Since we failed, remove items from OutputResources.  Note when extracting ResW
                        // files, we won't have added anything to OutputResources up front though.
                        if (!_extractResWFiles)
                        {
                            UnsuccessfullyCreatedOutFiles.Add(outputSpec);
                        }
                    }
                }
            }
            finally
            {
#if !FEATURE_ASSEMBLYLOADCONTEXT
                // Remove the event handler.
                AppDomain.CurrentDomain.AssemblyResolve -= _eventHandler;
                _eventHandler = null;
#endif
            }
        }

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Callback to resolve assembly names to assemblies.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        internal Assembly ResolveAssembly(object sender, ResolveEventArgs args)
        {
            AssemblyNameExtension requestedAssemblyName = new AssemblyNameExtension(args.Name);

            if (_assemblyFiles != null)
            {
                PopulateAssemblyNames();

                // Loop through all the references passed in, and see if any of them have an assembly
                // name that exactly matches the requested one.
                for (int i = 0; i < _assemblyNames.Length; i++)
                {
                    AssemblyNameExtension candidateAssemblyName = _assemblyNames[i];

                    if (candidateAssemblyName != null)
                    {
                        if (candidateAssemblyName.CompareTo(requestedAssemblyName) == 0)
                        {
                            return Assembly.UnsafeLoadFrom(_assemblyFiles[i].ItemSpec);
                        }
                    }
                }

                // If none of the referenced assembly names matches exactly, try to find one that
                // has the same base name.  This is here to fix bug where the
                // serialized data inside the .RESX referred to the assembly just by the base name,
                // omitting the version, culture, publickeytoken information.
                for (int i = 0; i < _assemblyNames.Length; i++)
                {
                    AssemblyNameExtension candidateAssemblyName = _assemblyNames[i];

                    if (candidateAssemblyName != null)
                    {
                        if (String.Equals(requestedAssemblyName.Name, candidateAssemblyName.Name, StringComparison.CurrentCultureIgnoreCase))
                        {
                            return Assembly.UnsafeLoadFrom(_assemblyFiles[i].ItemSpec);
                        }
                    }
                }
            }

            return null;
        }
#endif

        private void PopulateAssemblyNames()
        {
            // Populate the list of assembly names for all passed-in references if it hasn't
            // been populated already.
            if (_assemblyNames == null)
            {
                _assemblyNames = new AssemblyNameExtension[_assemblyFiles.Length];
                for (int i = 0; i < _assemblyFiles.Length; i++)
                {
                    ITaskItem assemblyFile = _assemblyFiles[i];
                    _assemblyNames[i] = null;

                    if (assemblyFile.ItemSpec != null && FileSystems.Default.FileExists(assemblyFile.ItemSpec))
                    {
                        string fusionName = assemblyFile.GetMetadata(ItemMetadataNames.fusionName);
                        if (!String.IsNullOrEmpty(fusionName))
                        {
                            _assemblyNames[i] = new AssemblyNameExtension(fusionName);
                        }
                        else
                        {
                            // whoever passed us this reference wasn't polite enough to also
                            // give us a metadata with the fusion name.  Trying to load up every
                            // assembly here would take a lot of time, so just stick the assembly
                            // file name (which we assume generally maps to the simple name) into
                            // the list instead. If there's a fusion name that matches, we'll get
                            // that first; otherwise there's a good chance that if the simple name
                            // matches the file name, it's a good match.
                            _assemblyNames[i] = new AssemblyNameExtension(Path.GetFileNameWithoutExtension(assemblyFile.ItemSpec));
                        }
                    }
                }
            }
        }

        #region Code from ResGen.EXE

        /// <summary>
        /// Read all resources from a file and write to a new file in the chosen format
        /// </summary>
        /// <remarks>Uses the input and output file extensions to determine their format</remarks>
        /// <param name="inFile">Input resources file</param>
        /// <param name="outFileOrDir">Output resources file or directory</param>
        /// <returns>True if conversion was successful, otherwise false</returns>
        private bool ProcessFile(string inFile, string outFileOrDir)
        {
            Format inFileFormat = GetFormat(inFile);
            if (inFileFormat == Format.Error)
            {
                // GetFormat would have logged an error.
                return false;
            }
            if (inFileFormat != Format.Assembly) // outFileOrDir is a directory when the input file is an assembly
            {
                Format outFileFormat = GetFormat(outFileOrDir);
                if (outFileFormat == Format.Assembly)
                {
                    _logger.LogErrorFromResources("GenerateResource.CannotWriteAssembly", outFileOrDir);
                    return false;
                }
                else if (outFileFormat == Format.Error)
                {
                    return false;
                }
            }

            if (!_extractResWFiles)
            {
                _logger.LogMessageFromResources("GenerateResource.ProcessingFile", inFile, outFileOrDir);
            }

            // Reset state
            _readers = new List<ReaderInfo>();

            try
            {
                ReadResources(inFile, _useSourcePath, outFileOrDir);
            }
            catch (InputFormatNotSupportedException)
            {
                _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), 0, 0, 0, 0,
                                                      "GenerateResource.CoreSupportsLimitedScenarios");
                return false;
            }
            catch (MSBuildResXException msbuildResXException)
            {
                _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), 0, 0, 0, 0,
                    "General.InvalidResxFile", msbuildResXException.InnerException.ToString());
                return false;
            }
            catch (ArgumentException ae)
            {
                if (ae.InnerException is XmlException xe)
                {
                    _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), xe.LineNumber,
                        xe.LinePosition, 0, 0, "General.InvalidResxFile", xe.Message);
                }
                else
                {
                    _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), 0, 0, 0, 0,
                        "General.InvalidResxFile", ae.Message);
                }
                return false;
            }
            catch (TextFileException tfe)
            {
                // Used to pass back error context from ReadTextResources to here.
                _logger.LogErrorWithCodeFromResources(null, tfe.FileName, tfe.LineNumber, tfe.LinePosition, 1, 1,
                    "GenerateResource.MessageTunnel", tfe.Message);
                return false;
            }
            catch (XmlException xe)
            {
                _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), xe.LineNumber,
                    xe.LinePosition, 0, 0, "General.InvalidResxFile", xe.Message);
                return false;
            }
            catch (Exception e) when (
                                      e is SerializationException ||
                                      e is TargetInvocationException)
            {
                // DDB #9819
                // SerializationException and TargetInvocationException can occur when trying to deserialize a type from a resource format (typically with other exceptions inside)
                // This is a bug in the type being serialized, so the best we can do is dump diagnostic information and move on to the next input resource file.
                _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), 0, 0, 0, 0,
                    "General.InvalidResxFile", e.Message);

                // Log the stack, so the problem with the type in the .resx is diagnosable by the customer
                _logger.LogErrorFromException(e, /* stack */ true, /* inner exceptions */ true,
                    FileUtilities.GetFullPathNoThrow(inFile));
                return false;
            }
            catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
            {
                // Regular IO error
                _logger.LogErrorWithCodeFromResources(null, FileUtilities.GetFullPathNoThrow(inFile), 0, 0, 0, 0,
                    "General.InvalidResxFile", e.Message);
                return false;
            }

            string currentOutputFile = null;
            string currentOutputDirectory = null;
            string currentOutputSourceCodeFile = null;
            bool currentOutputDirectoryAlreadyExisted = true;

            try
            {
                if (GetFormat(inFile) == Format.Assembly)
                {
                    // Prepare cache data
                    ResGenDependencies.PortableLibraryFile library = new ResGenDependencies.PortableLibraryFile(inFile);
                    List<string> resWFilesForThisAssembly = new List<string>();

                    foreach (ReaderInfo reader in _readers)
                    {
                        String currentOutputFileNoPath = reader.outputFileName + ".resw";
                        currentOutputFile = null;
                        currentOutputDirectoryAlreadyExisted = true;
                        string priDirectory = Path.Combine(outFileOrDir ?? String.Empty,
                            reader.assemblySimpleName);
                        currentOutputDirectory = Path.Combine(priDirectory,
                            reader.cultureName ?? String.Empty);

                        if (!FileSystems.Default.DirectoryExists(currentOutputDirectory))
                        {
                            currentOutputDirectoryAlreadyExisted = false;
                            Directory.CreateDirectory(currentOutputDirectory);
                        }
                        currentOutputFile = Path.Combine(currentOutputDirectory, currentOutputFileNoPath);

                        // For very long resource names, this directory structure may be too deep.
                        // If so, assume that the name is so long it will already uniquely distinguish itself.
                        // However for shorter names we'd still prefer to use the assembly simple name
                        // in the path to avoid conflicts.
                        currentOutputFile = EnsurePathIsShortEnough(currentOutputFile, currentOutputFileNoPath,
                            outFileOrDir, reader.cultureName);

                        if (currentOutputFile == null)
                        {
                            // We couldn't generate a file name short enough to handle this.  Fail but continue.
                            continue;
                        }

                        // Always write the output file here - other logic prevents us from processing this
                        // file for incremental builds if everything was up to date.
                        WriteResources(reader, currentOutputFile);

                        string escapedOutputFile = EscapingUtilities.Escape(currentOutputFile);
                        ITaskItem newOutputFile = new TaskItem(escapedOutputFile);
                        resWFilesForThisAssembly.Add(escapedOutputFile);
                        newOutputFile.SetMetadata("ResourceIndexName", reader.assemblySimpleName);
                        library.AssemblySimpleName = reader.assemblySimpleName;
                        if (reader.fromNeutralResources)
                        {
                            newOutputFile.SetMetadata("NeutralResourceLanguage", reader.cultureName);
                            library.NeutralResourceLanguage = reader.cultureName;
                        }
                        ExtractedResWFiles.Add(newOutputFile);
                    }

                    library.OutputFiles = resWFilesForThisAssembly.ToArray();
                    _portableLibraryCacheInfo.Add(library);
                }
                else
                {
                    currentOutputFile = outFileOrDir;
                    ErrorUtilities.VerifyThrow(_readers.Count == 1,
                        "We have no readers, or we have multiple readers & are ignoring subsequent ones.  Num readers: {0}",
                        _readers.Count);
                    WriteResources(_readers[0], outFileOrDir);
                }

                if (_stronglyTypedLanguage != null)
                {
                    try
                    {
                        ErrorUtilities.VerifyThrow(_readers.Count == 1,
                            "We have no readers, or we have multiple readers & are ignoring subsequent ones.  Num readers: {0}",
                            _readers.Count);
                        CreateStronglyTypedResources(_readers[0], outFileOrDir, inFile, out currentOutputSourceCodeFile);
                    }
                    catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
                    {
                        // IO Error
                        _logger.LogErrorWithCodeFromResources("GenerateResource.CannotWriteSTRFile",
                            _stronglyTypedFilename, e.Message);

                        if (FileSystems.Default.FileExists(outFileOrDir)
                            && GetFormat(inFile) != Format.Assembly
                            // outFileOrDir is a directory when the input file is an assembly
                            && GetFormat(outFileOrDir) != Format.Assembly)
                        // Never delete an assembly since we don't ever actually write to assemblies.
                        {
                            RemoveCorruptedFile(outFileOrDir);
                        }
                        if (currentOutputSourceCodeFile != null)
                        {
                            RemoveCorruptedFile(currentOutputSourceCodeFile);
                        }
                        return false;
                    }
                }
            }
            catch (IOException io)
            {
                if (currentOutputFile != null)
                {
                    _logger.LogErrorWithCodeFromResources("GenerateResource.CannotWriteOutput",
                        FileUtilities.GetFullPathNoThrow(currentOutputFile), io.Message);
                    if (FileSystems.Default.FileExists(currentOutputFile))
                    {
                        if (GetFormat(currentOutputFile) != Format.Assembly)
                        // Never delete an assembly since we don't ever actually write to assemblies.
                        {
                            RemoveCorruptedFile(currentOutputFile);
                        }
                    }
                }

                if (currentOutputDirectory != null &&
                    !currentOutputDirectoryAlreadyExisted)
                {
                    // Do not annoy the user by removing an empty directory we did not create.
                    try
                    {
                        Directory.Delete(currentOutputDirectory); // Remove output directory if empty
                    }
                    catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
                    {
                        // Fail silently (we are not even checking if the call to File.Delete succeeded)
                    }
                }
                return false;
            }
            catch (Exception e) when (
                                      e is SerializationException ||
                                      e is TargetInvocationException)
            {
                // DDB #9819
                // SerializationException and TargetInvocationException can occur when trying to serialize a type into a resource format (typically with other exceptions inside)
                // This is a bug in the type being serialized, so the best we can do is dump diagnostic information and move on to the next input resource file.
                _logger.LogErrorWithCodeFromResources("GenerateResource.CannotWriteOutput",
                    FileUtilities.GetFullPathNoThrow(inFile), e.Message); // Input file is more useful to log

                // Log the stack, so the problem with the type in the .resx is diagnosable by the customer
                _logger.LogErrorFromException(e, /* stack */ true, /* inner exceptions */ true,
                    FileUtilities.GetFullPathNoThrow(inFile));
                return false;
            }
            catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
            {
                // Regular IO error
                _logger.LogErrorWithCodeFromResources("GenerateResource.CannotWriteOutput",
                    FileUtilities.GetFullPathNoThrow(currentOutputFile), e.Message);
                return false;
            }

            return true;
        }

        /// <summary>
        /// For very long resource names, the directory structure we generate may be too deep.
        /// If so, assume that the name is so long it will already uniquely distinguish itself.
        /// However for shorter names we'd still prefer to use the assembly simple name
        /// in the path to avoid conflicts.
        /// </summary>
        /// <param name="currentOutputFile">The current path name</param>
        /// <param name="currentOutputFileNoPath">The current file name without a path.</param>
        /// <param name="outputDirectory">Output directory path</param>
        /// <param name="cultureName">culture for this resource</param>
        /// <returns>The current path or a shorter one.</returns>
        private string EnsurePathIsShortEnough(string currentOutputFile, string currentOutputFileNoPath, string outputDirectory, string cultureName)
        {
            if (!NativeMethodsShared.HasMaxPath)
            {
                return Path.GetFullPath(currentOutputFile);
            }

            // File names >= 260 characters won't work.  File names of exactly 259 characters are odd though.
            // They seem to work with Notepad and Windows Explorer, but not with MakePri.  They don't work
            // reliably with cmd's dir command either (depending on whether you use absolute or relative paths
            // and whether there are quotes around the name).
            const int EffectiveMaxPath = 258;   // Everything <= EffectiveMaxPath should work well.
            bool success;
            try
            {
                currentOutputFile = Path.GetFullPath(currentOutputFile);
                success = currentOutputFile.Length <= EffectiveMaxPath;
            }
            catch (PathTooLongException)
            {
                success = false;
            }

            if (!success)
            {
                string shorterPath = Path.Combine(outputDirectory ?? String.Empty, cultureName ?? String.Empty);
                if (!FileSystems.Default.DirectoryExists(shorterPath))
                {
                    Directory.CreateDirectory(shorterPath);
                }
                currentOutputFile = Path.Combine(shorterPath, currentOutputFileNoPath);

                // Try again
                try
                {
                    currentOutputFile = Path.GetFullPath(currentOutputFile);
                    success = currentOutputFile.Length <= EffectiveMaxPath;
                }
                catch (PathTooLongException)
                {
                    success = false;
                }

                // Can't do anything more without violating correctness.
                if (!success)
                {
                    _logger.LogErrorWithCodeFromResources("GenerateResource.PathTooLong", currentOutputFile);
                    currentOutputFile = null;
                    // We've logged an error message.  This MSBuild task will fail, but can continue processing other input (to find other errors).
                }
            }
            return currentOutputFile;
        }

        /// <summary>
        /// Remove a corrupted file, with error handling and a warning if we fail.
        /// </summary>
        /// <param name="filename">Full path to file to delete</param>
        private void RemoveCorruptedFile(string filename)
        {
            _logger.LogMessageFromResources("GenerateResource.CorruptOutput", FileUtilities.GetFullPathNoThrow(filename));
            try
            {
                File.Delete(filename);
            }
            catch (Exception deleteException)
            {
                _logger.LogWarningWithCodeFromResources("GenerateResource.DeleteCorruptOutputFailed", FileUtilities.GetFullPathNoThrow(filename), deleteException.Message);

                if (ExceptionHandling.NotExpectedException(deleteException))
                {
                    throw;
                }
            }
        }

        /// <summary>
        /// Figure out the format of an input resources file from the extension
        /// </summary>
        /// <param name="filename">Input resources file</param>
        /// <returns>Resources format</returns>
        private Format GetFormat(string filename)
        {
            string extension;
            try
            {
                extension = Path.GetExtension(filename);
            }
            catch (ArgumentException ex)
            {
                _logger.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", filename, ex.Message);
                return Format.Error;
            }

            if (String.Equals(extension, ".txt", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(extension, ".restext", StringComparison.OrdinalIgnoreCase))
            {
                return Format.Text;
            }
            else if (String.Equals(extension, ".resx", StringComparison.OrdinalIgnoreCase) ||
                     String.Equals(extension, ".resw", StringComparison.OrdinalIgnoreCase))
            {
                return Format.XML;
            }
            else if (String.Equals(extension, ".resources.dll", StringComparison.OrdinalIgnoreCase) ||
                     String.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) ||
                     String.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase))
            {
                return Format.Assembly;
            }
            else if (String.Equals(extension, ".resources", StringComparison.OrdinalIgnoreCase))
            {
                return Format.Binary;
            }
            else
            {
                _logger.LogErrorWithCodeFromResources("GenerateResource.UnknownFileExtension", Path.GetExtension(filename), filename);
                return Format.Error;
            }
        }

        /// <summary>
        /// Text files are just name/value pairs.  ResText is the same format
        /// with a unique extension to work around some ambiguities with MSBuild
        /// ResX is our existing XML format from V1.
        /// </summary>
        private enum Format
        {
            Text, // .txt or .restext
            XML, // .resx
            Binary, // .resources
            Assembly, // .dll, .exe or .resources.dll
            Error, // anything else
        }

        /// <summary>
        /// Reads the resources out of the specified file and populates the
        /// resources hashtable.
        /// </summary>
        /// <param name="filename">Filename to load</param>
        /// <param name="shouldUseSourcePath">Whether to resolve paths in the
        /// resources file relative to the resources file location</param>
        /// <param name="outFileOrDir"> Output file or directory. </param>
        private void ReadResources(String filename, bool shouldUseSourcePath, String outFileOrDir)
        {
            Format format = GetFormat(filename);

            if (format == Format.Assembly) // Multiple input .resources files within one assembly
            {
#if !FEATURE_ASSEMBLYLOADCONTEXT
                ReadAssemblyResources(filename, outFileOrDir);
#else
                throw new InputFormatNotSupportedException("Reading resources from Assembly not supported on .NET Core MSBuild");
#endif
            }
            else
            {
                ReaderInfo reader = new ReaderInfo();
                _readers.Add(reader);
                switch (format)
                {
                    case Format.Text:
                        ReadTextResources(reader, filename);
                        break;

                    case Format.XML:
                        // On full framework, the default is to use the longstanding
                        // deserialize/reserialize approach. On Core, always use the new
                        // preserialized approach.
#if FEATURE_RESXREADER_LIVEDESERIALIZATION
                        if (!_usePreserializedResources)
                        {
                            ResXResourceReader resXReader = null;
                            if (_typeResolver != null)
                            {
                                resXReader = new ResXResourceReader(filename, _typeResolver);
                            }
                            else
                            {
                                resXReader = new ResXResourceReader(filename);
                            }

                            if (shouldUseSourcePath)
                            {
                                String fullPath = Path.GetFullPath(filename);
                                resXReader.BasePath = Path.GetDirectoryName(fullPath);
                            }
                            // ReadResources closes the reader for us
                            ReadResources(reader, resXReader, filename);
                        }
                        else
#endif
                        {
                            if (Traits.Instance.EscapeHatches.UseMinimalResxParsingInCoreScenarios)
                            {
                                AddResourcesUsingMinimalCoreResxParsing(filename, reader);
                            }
                            else
                            {
                                foreach (IResource resource in MSBuildResXReader.GetResourcesFromFile(filename, shouldUseSourcePath, _logger, _logWarningForBinaryFormatter))
                                {
                                    AddResource(reader, resource, filename, 0, 0);
                                }
                            }
                        }
                        break;

                    case Format.Binary:
#if FEATURE_RESXREADER_LIVEDESERIALIZATION
                        ReadResources(reader, new ResourceReader(filename), filename); // closes reader for us
                        break;
#else
                        throw new InputFormatNotSupportedException("Reading resources from binary .resources not supported on .NET Core MSBuild");
#endif

                    default:
                        // We should never get here, we've already checked the format
                        Debug.Fail($"Unknown format {format}");
                        return;
                }
                _logger.LogMessageFromResources(MessageImportance.Low, "GenerateResource.ReadResourceMessage", reader.resources.Count, filename);
            }
        }

        /// <summary>
        /// Legacy Core implementation of string-only ResX handling
        /// </summary>
        private void AddResourcesUsingMinimalCoreResxParsing(string filename, ReaderInfo reader)
        {
            using (var xmlReader = new XmlTextReader(filename))
            {
                xmlReader.WhitespaceHandling = WhitespaceHandling.None;
                XDocument doc = XDocument.Load(xmlReader, LoadOptions.PreserveWhitespace);
                foreach (XElement dataElem in doc.Element("root").Elements("data"))
                {
                    string name = dataElem.Attribute("name").Value;
                    string value = dataElem.Element("value").Value;
                    AddResource(reader, name, value, filename);
                }
            }
        }

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Reads resources from an assembly.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="outFileOrDir"> Output file or directory. </param>
        /// <remarks> This should not run for Framework assemblies. </remarks>
        internal void ReadAssemblyResources(String name, String outFileOrDir)
        {
            // If something else in the solution failed to build...
            if (!FileSystems.Default.FileExists(name))
            {
                _logger.LogErrorWithCodeFromResources("GenerateResource.MissingFile", name);
                return;
            }

            Assembly a = null;
            bool mainAssembly = false;
            bool failedLoadingCultureInfo = false;
            NeutralResourcesLanguageAttribute neutralResourcesLanguageAttribute = null;
            AssemblyName assemblyName = null;

            try
            {
                a = Assembly.UnsafeLoadFrom(name);
                assemblyName = a.GetName();

                if (_extractResWFiles)
                {
                    var targetFrameworkAttribute = a.GetCustomAttribute<TargetFrameworkAttribute>();
                    if (
                            targetFrameworkAttribute != null &&
                            (
                                targetFrameworkAttribute.FrameworkName.StartsWith("Silverlight,", StringComparison.OrdinalIgnoreCase) ||
                                targetFrameworkAttribute.FrameworkName.StartsWith("WindowsPhone,", StringComparison.OrdinalIgnoreCase)))
                    {
                        // Skip Silverlight assemblies.
                        _logger.LogMessageFromResources("GenerateResource.SkippingExtractingFromNonSupportedFramework", name, targetFrameworkAttribute.FrameworkName);
                        return;
                    }

                    _logger.LogMessageFromResources("GenerateResource.ExtractingResWFiles", name, outFileOrDir);
                }

                CultureInfo ci = null;
                try
                {
                    ci = assemblyName.CultureInfo;
                }
                catch (ArgumentException e)
                {
                    _logger.LogWarningWithCodeFromResources(null, name, 0, 0, 0, 0, "GenerateResource.CreatingCultureInfoFailed", e.GetType().Name, e.Message, assemblyName.ToString());
                    failedLoadingCultureInfo = true;
                }

                if (!failedLoadingCultureInfo)
                {
                    mainAssembly = ci.Equals(CultureInfo.InvariantCulture);
                    neutralResourcesLanguageAttribute = CheckAssemblyCultureInfo(name, assemblyName, ci, a, mainAssembly);
                }  // if (!failedLoadingCultureInfo)
            }
            catch (BadImageFormatException)
            {
                // If we're extracting ResW files, this task is being run on all DLL's referred to by the project.
                // That may potentially include C++ libraries & immersive (non-portable) class libraries, which don't have resources.
                // We can't easily filter those.  We can simply skip them.
                return;
            }
            catch (ArgumentException e) when (e.InnerException is BadImageFormatException)
            {
                // BadImageFormatExceptions can be wrapped in ArgumentExceptions, so catch those, too. See https://referencesource.microsoft.com/#mscorlib/system/reflection/module.cs,857
                return;
            }
            catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
            {
                _logger.LogErrorWithCodeFromResources("GenerateResource.CannotLoadAssemblyLoadFromFailed", name, e);
            }

            if (a != null)
            {
                String[] resources = a.GetManifestResourceNames();
                CultureInfo satCulture = null;
                String expectedExt = null;
                if (!failedLoadingCultureInfo)
                {
                    satCulture = assemblyName.CultureInfo;
                    if (!satCulture.Equals(CultureInfo.InvariantCulture))
                    {
                        expectedExt = '.' + satCulture.Name + ".resources";
                    }
                }

                foreach (String resName in resources)
                {
                    if (!resName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase)) // Skip non-.resources assembly blobs
                    {
                        continue;
                    }

                    if (mainAssembly)
                    {
                        if (CultureInfo.InvariantCulture.CompareInfo.IsSuffix(resName, ".en-US.resources", CompareOptions.IgnoreCase))
                        {
                            _logger.LogErrorFromResources("GenerateResource.ImproperlyBuiltMainAssembly", resName, name);
                            continue;
                        }

                        if (neutralResourcesLanguageAttribute == null)
                        {
                            _logger.LogWarningWithCodeFromResources(null, name, 0, 0, 0, 0, "GenerateResource.MainAssemblyMissingNeutralResourcesLanguage", name);
                            break;
                        }
                    }
                    else if (!failedLoadingCultureInfo && !CultureInfo.InvariantCulture.CompareInfo.IsSuffix(resName, expectedExt, CompareOptions.IgnoreCase))
                    {
                        _logger.LogErrorFromResources("GenerateResource.ImproperlyBuiltSatelliteAssembly", resName, expectedExt, name);
                        continue;
                    }

                    try
                    {
                        Stream s = a.GetManifestResourceStream(resName);
                        using (IResourceReader rr = new ResourceReader(s))
                        {
                            ReaderInfo reader = new ReaderInfo();
                            if (mainAssembly)
                            {
                                reader.fromNeutralResources = true;
                                reader.assemblySimpleName = assemblyName.Name;
                            }
                            else
                            {
                                Debug.Assert(assemblyName.Name.EndsWith(".resources", StringComparison.OrdinalIgnoreCase));
                                reader.assemblySimpleName = assemblyName.Name.Remove(assemblyName.Name.Length - 10);  // Remove .resources from satellite assembly name
                            }
                            reader.outputFileName = resName.Remove(resName.Length - 10); // Remove the .resources extension
                            if (satCulture != null && !String.IsNullOrEmpty(satCulture.Name))
                            {
                                reader.cultureName = satCulture.Name;
                            }
                            else if (neutralResourcesLanguageAttribute != null && !String.IsNullOrEmpty(neutralResourcesLanguageAttribute.CultureName))
                            {
                                reader.cultureName = neutralResourcesLanguageAttribute.CultureName;
                            }

                            if (reader.cultureName != null)
                            {
                                // Remove the culture from the filename
                                if (reader.outputFileName.EndsWith("." + reader.cultureName, StringComparison.OrdinalIgnoreCase))
                                {
                                    reader.outputFileName = reader.outputFileName.Remove(reader.outputFileName.Length - (reader.cultureName.Length + 1));
                                }
                            }
                            _readers.Add(reader);

                            foreach (DictionaryEntry pair in rr)
                            {
                                AddResource(reader, (string)pair.Key, pair.Value, resName);
                            }
                        }
                    }
                    catch (FileNotFoundException)
                    {
                        _logger.LogErrorWithCodeFromResources(null, name, 0, 0, 0, 0, "GenerateResource.NoResourcesFileInAssembly", resName);
                    }
                }
            }

            var satelliteAssemblies = _satelliteInFiles.Where(ti => ti.GetMetadata("OriginalItemSpec").Equals(name, StringComparison.OrdinalIgnoreCase));

            foreach (var satelliteAssembly in satelliteAssemblies)
            {
                ReadAssemblyResources(satelliteAssembly.ItemSpec, outFileOrDir);
            }
        }

        /// <summary>
        /// Checks the consistency of the CultureInfo and NeutralResourcesLanguageAttribute settings.
        /// </summary>
        /// <param name="name">Assembly's file name</param>
        /// <param name="assemblyName">AssemblyName of this assembly</param>
        /// <param name="culture">Assembly's CultureInfo</param>
        /// <param name="a">The actual Assembly</param>
        /// <param name="mainAssembly">Whether this is the main assembly</param>
        private NeutralResourcesLanguageAttribute CheckAssemblyCultureInfo(String name, AssemblyName assemblyName, CultureInfo culture, Assembly a, bool mainAssembly)
        {
            NeutralResourcesLanguageAttribute neutralResourcesLanguageAttribute = null;
            if (mainAssembly)
            {
                Object[] attrs = a.GetCustomAttributes(typeof(NeutralResourcesLanguageAttribute), false);
                if (attrs.Length != 0)
                {
                    neutralResourcesLanguageAttribute = (NeutralResourcesLanguageAttribute)attrs[0];
                    bool fallbackToSatellite = neutralResourcesLanguageAttribute.Location == UltimateResourceFallbackLocation.Satellite;
                    if (!fallbackToSatellite && neutralResourcesLanguageAttribute.Location != UltimateResourceFallbackLocation.MainAssembly)
                    {
                        _logger.LogWarningWithCodeFromResources(null, name, 0, 0, 0, 0, "GenerateResource.UnrecognizedUltimateResourceFallbackLocation", neutralResourcesLanguageAttribute.Location, name);
                    }
                    // This MSBuild task needs to not report an error for main assemblies that don't have managed resources.
                }
            }
            else
            {  // Satellite assembly, or a mal-formed main assembly
                // Additional error checking from ResView.
                if (!assemblyName.Name.EndsWith(".resources", StringComparison.OrdinalIgnoreCase))
                {
                    _logger.LogWarningWithCodeFromResources(null, name, 0, 0, 0, 0, "GenerateResource.SatelliteOrMalformedAssembly", name, culture.Name, assemblyName.Name);
                    return null;
                }
                Type[] types = a.GetTypes();
                if (types.Length > 0)
                {
                    _logger.LogWarningWithCodeFromResources("GenerateResource.SatelliteAssemblyContainsCode", name);
                }

                if (!ContainsProperlyNamedResourcesFiles(a, false))
                {
                    _logger.LogWarningWithCodeFromResources("GenerateResource.SatelliteAssemblyContainsNoResourcesFile", assemblyName.CultureInfo.Name);
                }
            }
            return neutralResourcesLanguageAttribute;
        }

        private static bool ContainsProperlyNamedResourcesFiles(Assembly a, bool mainAssembly)
        {
            String postfix = mainAssembly ? ".resources" : a.GetName().CultureInfo.Name + ".resources";
            foreach (String manifestResourceName in a.GetManifestResourceNames())
            {
                if (manifestResourceName.EndsWith(postfix, StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
            }

            return false;
        }
#endif

        /// <summary>
        /// Write resources from the resources ArrayList to the specified output file
        /// </summary>
        /// <param name="reader">Reader information</param>
        /// <param name="filename">Output resources file</param>
        private void WriteResources(ReaderInfo reader, String filename)
        {
            Format format = GetFormat(filename);
            switch (format)
            {
                case Format.Text:
                    WriteTextResources(reader, filename);
                    break;

                case Format.XML:
#if FEATURE_RESXREADER_LIVEDESERIALIZATION
                    WriteResources(reader, new ResXResourceWriter(filename)); // closes writer for us
#else
                    _logger.LogError($"{format} not supported on .NET Core MSBuild");
#endif
                    break;

                case Format.Assembly:
                    _logger.LogErrorFromResources("GenerateResource.CannotWriteAssembly", filename);
                    break;

                case Format.Binary:
                    WriteBinaryResources(reader, filename);
                    break;

                default:
                    // We should never get here, we've already checked the format
                    Debug.Fail($"Unknown format {format}");
                    break;
            }
        }

        private void WriteBinaryResources(ReaderInfo reader, string filename)
        {
            if (_usePreserializedResources && HaveSystemResourcesExtensionsReference)
            {
                WriteResources(reader, new PreserializedResourceWriter(new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None))); // closes writer for us
                return;
            }

            try
            {
                WriteResources(reader, new ResourceWriter(new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None))); // closes writer for us
            }
            catch (PreserializedResourceWriterRequiredException)
            {
                if (!_usePreserializedResources)
                {
                    _logger.LogErrorWithCodeFromResources("GenerateResource.PreserializedResourcesRequiresProperty");
                }

                if (!HaveSystemResourcesExtensionsReference)
                {
                    _logger.LogErrorWithCodeFromResources("GenerateResource.PreserializedResourcesRequiresExtensions");
                }

                // one of the above should have been logged as we would have used preserialized writer otherwise.
                Debug.Assert(_logger.HasLoggedErrors);

                // We may have partially written some string resources to a file, then bailed out
                // because we encountered a non-string resource but don't meet the prereqs.
                RemoveCorruptedFile(filename);
            }
        }

        private bool? _haveSystemResourcesExtensionsReference;

        private bool HaveSystemResourcesExtensionsReference
        {
            get
            {
                if (_haveSystemResourcesExtensionsReference.HasValue)
                {
                    return _haveSystemResourcesExtensionsReference.Value;
                }

                if (_assemblyFiles == null)
                {
                    _haveSystemResourcesExtensionsReference = false;
                    return false;
                }

                PopulateAssemblyNames();

                foreach (AssemblyNameExtension assemblyName in _assemblyNames)
                {
                    if (assemblyName == null)
                    {
                        continue;
                    }

                    if (string.Equals(assemblyName.Name, "System.Resources.Extensions", StringComparison.OrdinalIgnoreCase))
                    {
                        _haveSystemResourcesExtensionsReference = true;
                        return true;
                    }
                }

                _haveSystemResourcesExtensionsReference = false;
                return false;
            }
        }

        /// <summary>
        /// Create a strongly typed resource class
        /// </summary>
        /// <param name="reader">Reader information</param>
        /// <param name="outFile">Output resource filename, for defaulting the class filename</param>
        /// <param name="inputFileName">Input resource filename, for error messages</param>
        /// <param name="sourceFile">The generated strongly typed filename</param>
        private void CreateStronglyTypedResources(ReaderInfo reader, String outFile, String inputFileName, out String sourceFile)
        {
            CodeDomProvider provider = null;
            try
            {
                if (!TryCreateCodeDomProvider(_logger, _stronglyTypedLanguage, out provider))
                {
                    sourceFile = null;
                    return;
                }


                // Default the class name if we need to
                if (_stronglyTypedClassName == null)
                {
                    _stronglyTypedClassName = Path.GetFileNameWithoutExtension(outFile);
                }

                // Default the filename if we need to
                if (_stronglyTypedFilename == null)
                {
                    _stronglyTypedFilename = GenerateDefaultStronglyTypedFilename(provider, outFile);
                }
                sourceFile = this.StronglyTypedFilename;

                _logger.LogMessageFromResources("GenerateResource.CreatingSTR", _stronglyTypedFilename);

                // Generate the STR class
                String[] errors;
                bool generateInternalClass = !_stronglyTypedClassIsPublic;
                // StronglyTypedResourcesNamespace can be null and this is ok.
                // If it is null then the default namespace (=stronglyTypedNamespace) is used.
                CodeCompileUnit ccu = StronglyTypedResourceBuilder.Create(
                        reader.resourcesHashTable,
                        _stronglyTypedClassName,
                        _stronglyTypedNamespace,
                        _stronglyTypedResourcesNamespace,
                        provider,
                        generateInternalClass,
                        out errors);

                CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
                using (TextWriter output = new StreamWriter(_stronglyTypedFilename))
                {
                    provider.GenerateCodeFromCompileUnit(ccu, output, codeGenOptions);
                }

                if (errors.Length > 0)
                {
                    _logger.LogErrorWithCodeFromResources("GenerateResource.ErrorFromCodeDom", inputFileName);
                    foreach (String error in errors)
                    {
                        _logger.LogErrorWithCodeFromResources("GenerateResource.CodeDomError", error);
                    }
                }
                else
                {
                    // No errors, and no exceptions - we presumably did create the STR class file
                    // and it should get added to FilesWritten. So set a flag to indicate this.
                    _stronglyTypedResourceSuccessfullyCreated = true;
                }
            }
            finally
            {
                provider?.Dispose();
            }
        }

        /// <summary>
        /// If no strongly typed resource class filename was specified, we come up with a default based on the
        /// input file name and the default language extension.
        /// </summary>
        /// <comments>
        /// Broken out here so it can be called from GenerateResource class.
        /// </comments>
        /// <param name="provider">A CodeDomProvider for the language</param>
        /// <param name="outputResourcesFile">Name of the output resources file</param>
        /// <returns>Filename for strongly typed resource class</returns>
        public static string GenerateDefaultStronglyTypedFilename(CodeDomProvider provider, string outputResourcesFile)
        {
            return Path.ChangeExtension(outputResourcesFile, provider.FileExtension);
        }

        /// <summary>
        /// Tries to create a CodeDom provider for the specified strongly typed language.  If successful, returns true,
        /// otherwise returns false.
        /// </summary>
        /// <comments>
        /// Broken out here so it can be called from GenerateResource class.
        /// Not a true "TryXXX" method, as it still throws if it encounters an exception it doesn't expect.
        /// </comments>
        /// <param name="logger">Logger helper.</param>
        /// <param name="stronglyTypedLanguage">The language to create a provider for.</param>
        /// <param name="provider">The provider in question, if one is successfully created.</param>
        /// <returns>True if the provider was successfully created, false otherwise.</returns>
        public static bool TryCreateCodeDomProvider(TaskLoggingHelper logger, string stronglyTypedLanguage, out CodeDomProvider provider)
        {
            provider = null;

            try
            {
                provider = CodeDomProvider.CreateProvider(stronglyTypedLanguage);
            }
            catch (Exception e) when
#if FEATURE_SYSTEM_CONFIGURATION
             (e is ConfigurationException || e is SecurityException)
#else
             (e is SystemException && e.GetType().Name == "ConfigurationErrorsException") // TODO: catch specific exception type once it is public https://github.com/dotnet/corefx/issues/40456
#endif
            {
                logger.LogErrorWithCodeFromResources("GenerateResource.STRCodeDomProviderFailed", stronglyTypedLanguage, e.Message);
                return false;
            }

            return provider != null;
        }

#if FEATURE_RESXREADER_LIVEDESERIALIZATION
        /// <summary>
        /// Read resources from an XML or binary format file
        /// </summary>
        /// <param name="readerInfo">Reader info</param>
        /// <param name="reader">Appropriate IResourceReader</param>
        /// <param name="fileName">Filename, for error messages</param>
        private void ReadResources(ReaderInfo readerInfo, IResourceReader reader, String fileName)
        {
            using (reader)
            {
                IDictionaryEnumerator resEnum = reader.GetEnumerator();
                while (resEnum.MoveNext())
                {
                    string name = (string)resEnum.Key;
                    object value = resEnum.Value;
                    AddResource(readerInfo, name, value, fileName);
                }
            }
        }
#endif // FEATURE_RESXREADER_LIVEDESERIALIZATION

        /// <summary>
        /// Read resources from a text format file.
        /// </summary>
        /// <param name="reader">Reader info.</param>
        /// <param name="fileName">Input resources filename.</param>
        private void ReadTextResources(ReaderInfo reader, String fileName)
        {
            // Check for byte order marks in the beginning of the input file, but
            // default to UTF-8.
            using var fs = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
            using (LineNumberStreamReader sr = new LineNumberStreamReader(fs, new UTF8Encoding(true), true))
            {
                StringBuilder name = new StringBuilder(255);
                StringBuilder value = new StringBuilder(2048);

                int ch = sr.Read();
                while (ch != -1)
                {
                    if (ch == '\n' || ch == '\r')
                    {
                        ch = sr.Read();
                        continue;
                    }

                    // Skip over commented lines or ones starting with whitespace.
                    // Support LocStudio INF format's comment char, ';'
                    if (ch == '#' || ch == '\t' || ch == ' ' || ch == ';')
                    {
                        // comment char (or blank line) - skip line.
                        sr.ReadLine();
                        ch = sr.Read();
                        continue;
                    }
                    // Note that in Beta of version 1 we recommended users should put a [strings]
                    // section in their file.  Now it's completely unnecessary and can
                    // only cause bugs.  We will not parse anything using '[' stuff now
                    // and we should give a warning about seeing [strings] stuff.
                    // In V1.1 or V2, we can rip this out completely, I hope.
                    if (ch == '[')
                    {
                        String skip = sr.ReadLine();
                        if (skip.Equals("strings]"))
                        {
                            _logger.LogWarningWithCodeFromResources(null, fileName, sr.LineNumber - 1, 1, 0, 0, "GenerateResource.ObsoleteStringsTag");
                        }
                        else
                        {
                            throw new TextFileException(_logger.FormatResourceString("GenerateResource.UnexpectedInfBracket", "[" + skip), fileName, sr.LineNumber - 1, 1);
                        }
                        ch = sr.Read();
                        continue;
                    }

                    // Read in name
                    name.Length = 0;
                    while (ch != '=')
                    {
                        if (ch == '\r' || ch == '\n')
                        {
                            throw new TextFileException(_logger.FormatResourceString("GenerateResource.NoEqualsInLine", name), fileName, sr.LineNumber, sr.LinePosition);
                        }

                        name.Append((char)ch);
                        ch = sr.Read();
                        if (ch == -1)
                        {
                            break;
                        }
                    }
                    if (name.Length == 0)
                    {
                        throw new TextFileException(_logger.FormatResourceString("GenerateResource.NoNameInLine"), fileName, sr.LineNumber, sr.LinePosition);
                    }

                    // For the INF file, we must allow a space on both sides of the equals
                    // sign.  Deal with it.
                    if (name[name.Length - 1] == ' ')
                    {
                        name.Length--;
                    }
                    ch = sr.Read(); // move past =

                    // If it exists, move past the first space after the equals sign.
                    if (ch == ' ')
                    {
                        ch = sr.Read();
                    }

                    // Read in value
                    value.Length = 0;

                    while (ch != -1)
                    {
                        // Did we read @"\r" or @"\n"?
                        bool quotedNewLine = false;
                        if (ch == '\\')
                        {
                            ch = sr.Read();
                            switch (ch)
                            {
                                case '\\':
                                    // nothing needed
                                    break;
                                case 'n':
                                    ch = '\n';
                                    quotedNewLine = true;
                                    break;
                                case 'r':
                                    ch = '\r';
                                    quotedNewLine = true;
                                    break;
                                case 't':
                                    ch = '\t';
                                    break;
                                case '"':
                                    ch = '\"';
                                    break;
                                case 'u':
                                    char[] hex = new char[4];
                                    int numChars = 4;
                                    int index = 0;
                                    while (numChars > 0)
                                    {
                                        int n = sr.Read(hex, index, numChars);
                                        if (n == 0)
                                        {
                                            throw new TextFileException(_logger.FormatResourceString("GenerateResource.InvalidEscape", name.ToString(), (char)ch), fileName, sr.LineNumber, sr.LinePosition);
                                        }

                                        index += n;
                                        numChars -= n;
                                    }
                                    try
                                    {
                                        ch = (char)UInt16.Parse(
#if NET
                                            hex,
#else
                                            new String(hex),
#endif
                                            NumberStyles.HexNumber, CultureInfo.CurrentCulture);
                                    }
                                    catch (FormatException)
                                    {
                                        // We know about this one...
                                        throw new TextFileException(_logger.FormatResourceString("GenerateResource.InvalidHexEscapeValue", name.ToString(), new String(hex)), fileName, sr.LineNumber, sr.LinePosition);
                                    }
                                    catch (OverflowException)
                                    {
                                        // We know about this one, too...
                                        throw new TextFileException(_logger.FormatResourceString("GenerateResource.InvalidHexEscapeValue", name.ToString(), new String(hex)), fileName, sr.LineNumber, sr.LinePosition);
                                    }
                                    quotedNewLine = (ch == '\n' || ch == '\r');
                                    break;

                                default:
                                    throw new TextFileException(_logger.FormatResourceString("GenerateResource.InvalidEscape", name.ToString(), (char)ch), fileName, sr.LineNumber, sr.LinePosition);
                            }
                        }

                        // Consume endline...
                        //   Endline can be \r\n or \n.  But do not treat a
                        //   quoted newline (ie, @"\r" or @"\n" in text) as a
                        //   real new line.  They aren't the end of a line.
                        if (!quotedNewLine)
                        {
                            if (ch == '\r')
                            {
                                ch = sr.Read();
                                if (ch == -1)
                                {
                                    break;
                                }
                                else if (ch == '\n')
                                {
                                    ch = sr.Read();
                                    break;
                                }
                            }
                            else if (ch == '\n')
                            {
                                ch = sr.Read();
                                break;
                            }
                        }

                        value.Append((char)ch);
                        ch = sr.Read();
                    }

                    // Note that value can be an empty string
                    AddResource(reader, name.ToString(), value.ToString(), fileName, sr.LineNumber, sr.LinePosition);
                }
            }
        }

        /// <summary>
        /// Write resources to an XML or binary format resources file.
        /// </summary>
        /// <remarks>Closes writer automatically</remarks>
        /// <param name="reader">Reader information</param>
        /// <param name="writer">Appropriate IResourceWriter</param>
        private void WriteResources(ReaderInfo reader,
            IResourceWriter writer)
        {
            Exception capturedException = null;
            try
            {
                foreach (IResource entry in reader.resources)
                {
                    entry.AddTo(writer);
                }
            }
            catch (Exception e)
            {
                capturedException = e; // Rethrow this after catching exceptions thrown by Close().
            }
            finally
            {
                if (capturedException == null)
                {
                    writer.Dispose(); // If this throws, exceptions will be caught upstream.
                }
                else
                {
                    // It doesn't hurt to call Close() twice. In the event of a full disk, we *need* to call Close() twice.
                    // In that case, the first time we catch an exception indicating that the XML written to disk is malformed,
                    // specifically an InvalidOperationException: "Token EndElement in state Error would result in an invalid XML document."
                    try { writer.Dispose(); }
                    catch (Exception) { } // We aggressively catch all exception types since we already have one we will throw.

                    // The second time we catch the out of disk space exception.
                    try { writer.Dispose(); }
                    catch (Exception) { } // We aggressively catch all exception types since we already have one we will throw.
                    throw capturedException; // In the event of a full disk, this is an out of disk space IOException.
                }
            }
        }

        /// <summary>
        /// Write resources to a text format resources file
        /// </summary>
        /// <param name="reader">Reader information</param>
        /// <param name="fileName">Output resources file</param>
        private void WriteTextResources(ReaderInfo reader, String fileName)
        {
            using (StreamWriter writer = FileUtilities.OpenWrite(fileName, false, Encoding.UTF8))
            {
                foreach (IResource resource in reader.resources)
                {
                    LiveObjectResource entry = resource as LiveObjectResource;

                    String key = entry?.Name;
                    Object v = entry?.Value;
                    String value = v as String;
                    if (value == null)
                    {
                        _logger.LogErrorWithCodeFromResources(null, fileName, 0, 0, 0, 0, "GenerateResource.OnlyStringsSupported", key, v?.GetType().FullName);
                    }
                    else
                    {
                        // Escape any special characters in the String.
                        value = value.Replace("\\", "\\\\");
                        value = value.Replace("\n", "\\n");
                        value = value.Replace("\r", "\\r");
                        value = value.Replace("\t", "\\t");

                        writer.WriteLine("{0}={1}", key, value);
                    }
                }
            }
        }

        /// <summary>
        /// Add a resource from a text file to the internal data structures
        /// </summary>
        /// <param name="reader">Reader information</param>
        /// <param name="name">Resource name</param>
        /// <param name="value">Resource value</param>
        /// <param name="inputFileName">Input file for messages</param>
        /// <param name="lineNumber">Line number for messages</param>
        /// <param name="linePosition">Column number for messages</param>
        private void AddResource(ReaderInfo reader, string name, object value, String inputFileName, int lineNumber, int linePosition)
        {
            LiveObjectResource entry = new LiveObjectResource(name, value);

            AddResource(reader, entry, inputFileName, lineNumber, linePosition);
        }

        private void AddResource(ReaderInfo reader, IResource entry, String inputFileName, int lineNumber, int linePosition)
        {
            if (reader.resourcesHashTable.ContainsKey(entry.Name))
            {
                _logger.LogWarningWithCodeFromResources(null, inputFileName, lineNumber, linePosition, 0, 0, "GenerateResource.DuplicateResourceName", entry.Name);
                return;
            }

            reader.resources.Add(entry);
            reader.resourcesHashTable.Add(entry.Name, entry);
        }

        /// <summary>
        /// Add a resource from an XML or binary format file to the internal data structures
        /// </summary>
        /// <param name="reader">Reader information.</param>
        /// <param name="name">Resource name.</param>
        /// <param name="value">Resource value.</param>
        /// <param name="inputFileName">Input file for messages.</param>
        private void AddResource(ReaderInfo reader, string name, object value, String inputFileName)
        {
            AddResource(reader, name, value, inputFileName, 0, 0);
        }

        internal sealed class ReaderInfo
        {
            public String outputFileName;
            public String cultureName;
            // We use a list to preserve the resource ordering (primarily for easier testing),
            // but also use a hash table to check for duplicate names.
            public List<IResource> resources;
            public Dictionary<string, IResource> resourcesHashTable;
            public String assemblySimpleName;  // The main assembly's simple name (ie, no .resources)
            public bool fromNeutralResources;  // Was this from the main assembly (or if the NRLA specified fallback to satellite, that satellite?)

            public ReaderInfo()
            {
                resources = new List<IResource>();
                resourcesHashTable = new Dictionary<string, IResource>(StringComparer.OrdinalIgnoreCase);
            }
        }

        /// <summary>
        /// Custom StreamReader that provides detailed position information,
        /// used when reading text format resources
        /// </summary>
        internal sealed class LineNumberStreamReader : StreamReader
        {
            // Line numbers start from 1, as well as line position.
            // For better error reporting, set line number to 1 and col to 0.
            private int _lineNumber;
            private int _col;

            internal LineNumberStreamReader(Stream fileStream, Encoding encoding, bool detectEncoding)
                : base(fileStream, encoding, detectEncoding)
            {
                _lineNumber = 1;
                _col = 0;
            }

            internal LineNumberStreamReader(Stream stream)
                : base(stream)
            {
                _lineNumber = 1;
                _col = 0;
            }

            public override int Read()
            {
                int ch = base.Read();
                if (ch != -1)
                {
                    _col++;
                    if (ch == '\n')
                    {
                        _lineNumber++;
                        _col = 0;
                    }
                }
                return ch;
            }

            public override int Read([In, Out] char[] chars, int index, int count)
            {
                int r = base.Read(chars, index, count);
                for (int i = 0; i < r; i++)
                {
                    if (chars[i + index] == '\n')
                    {
                        _lineNumber++;
                        _col = 0;
                    }
                    else
                    {
                        _col++;
                    }
                }
                return r;
            }

            public override String ReadLine()
            {
                String s = base.ReadLine();
                if (s != null)
                {
                    _lineNumber++;
                    _col = 0;
                }
                return s;
            }

            public override String ReadToEnd()
            {
                throw new NotImplementedException("NYI");
            }

            internal int LineNumber
            {
                get { return _lineNumber; }
            }

            internal int LinePosition
            {
                get { return _col; }
            }
        }

        /// <summary>
        /// For flow of control and passing sufficient error context back
        /// from ReadTextResources
        /// </summary>
        [Serializable]
        internal sealed class TextFileException : Exception
        {
            private String fileName;
            private int lineNumber;
            private int column;

#if NET8_0_OR_GREATER
            [Obsolete(DiagnosticId = "SYSLIB0051")]
#endif
            private TextFileException(SerializationInfo info, StreamingContext context)
                : base(info, context)
            {
            }

            internal TextFileException(String message, String fileName, int lineNumber, int linePosition)
                : base(message)
            {
                this.fileName = fileName;
                this.lineNumber = lineNumber;
                column = linePosition;
            }

            internal String FileName
            {
                get { return fileName; }
            }

            internal int LineNumber
            {
                get { return lineNumber; }
            }

            internal int LinePosition
            {
                get { return column; }
            }
        }
        #endregion // Code from ResGen.EXE
    }

#if !FEATURE_ASSEMBLYLOADCONTEXT
    /// <summary>
    /// This implemention of ITypeResolutionService is passed into the ResxResourceReader
    /// class, which calls back into the methods on this class in order to resolve types
    /// and assemblies that are referenced inside of the .RESX.
    /// </summary>
    internal class AssemblyNamesTypeResolutionService : ITypeResolutionService
    {
        private Hashtable _cachedAssemblies;
        private ITaskItem[] _referencePaths;
        private Hashtable _cachedTypes = new Hashtable();

        /// <summary>
        /// Constructor, initialized with the set of resolved reference paths passed
        /// into the GenerateResource task.
        /// </summary>
        /// <param name="referencePaths"></param>
        internal AssemblyNamesTypeResolutionService(ITaskItem[] referencePaths)
        {
            _referencePaths = referencePaths;
        }

        /// <summary>
        /// Not implemented.  Not called by the ResxResourceReader.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public Assembly GetAssembly(AssemblyName name)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Not implemented.  Not called by the ResxResourceReader.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="throwOnError"></param>
        /// <returns></returns>
        public Assembly GetAssembly(AssemblyName name, bool throwOnError)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Given a path to an assembly, load the assembly if it's not already loaded.
        /// </summary>
        /// <param name="pathToAssembly"></param>
        /// <param name="throwOnError"></param>
        /// <returns></returns>
        private Assembly GetAssemblyByPath(string pathToAssembly, bool throwOnError)
        {
            if (_cachedAssemblies == null)
            {
                _cachedAssemblies = new Hashtable();
            }

            if (!_cachedAssemblies.Contains(pathToAssembly))
            {
                try
                {
                    _cachedAssemblies[pathToAssembly] = Assembly.UnsafeLoadFrom(pathToAssembly);
                }
                catch when (!throwOnError)
                {
                }
            }

            return (Assembly)_cachedAssemblies[pathToAssembly];
        }

        /// <summary>
        /// Not implemented.  Not called by the ResxResourceReader.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public string GetPathOfAssembly(AssemblyName name)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Returns the type with the specified name.  Searches for the type in all
        /// of the assemblies passed into the References parameter of the GenerateResource
        /// task.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public Type GetType(string name)
        {
            return GetType(name, true);
        }

        /// <summary>
        /// Returns the type with the specified name.  Searches for the type in all
        /// of the assemblies passed into the References parameter of the GenerateResource
        /// task.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="throwOnError"></param>
        /// <returns></returns>
        public Type GetType(string name, bool throwOnError)
        {
            return GetType(name, throwOnError, false);
        }

        /// <summary>
        /// Returns the type with the specified name.  Searches for the type in all
        /// of the assemblies passed into the References parameter of the GenerateResource
        /// task.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="throwOnError"></param>
        /// <param name="ignoreCase"></param>
        /// <returns></returns>
        public Type GetType(string name, bool throwOnError, bool ignoreCase)
        {
            Type resultFromCache = (Type)_cachedTypes[name];

            if (!_cachedTypes.Contains(name))
            {
                // first try to resolve in the GAC
                Type result = Type.GetType(name, false, ignoreCase);

                // did not find it in the GAC, check each assembly
                if ((result == null) && (_referencePaths != null))
                {
                    foreach (ITaskItem referencePath in _referencePaths)
                    {
                        Assembly a = this.GetAssemblyByPath(referencePath.ItemSpec, throwOnError);
                        if (a != null)
                        {
                            result = a.GetType(name, false, ignoreCase);
                            if (result == null)
                            {
                                int indexOfComma = name.IndexOf(',');
                                if (indexOfComma != -1)
                                {
                                    string shortName = name.Substring(0, indexOfComma);
                                    result = a.GetType(shortName, false, ignoreCase);
                                }
                            }

                            if (result != null)
                            {
                                break;
                            }
                        }
                    }
                }

                if (result == null && throwOnError)
                {
                    ErrorUtilities.ThrowArgument("GenerateResource.CouldNotLoadType", name);
                }

                _cachedTypes[name] = result;
                resultFromCache = result;
            }

            return resultFromCache;
        }

        /// <summary>
        /// Not implemented.  Not called by the ResxResourceReader.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public void ReferenceAssembly(AssemblyName name)
        {
            throw new NotSupportedException();
        }
    }
#endif
}
